1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/message_loop/message_loop.h"
6#include "base/run_loop.h"
7#include "content/browser/browser_thread_impl.h"
8#include "content/public/browser/devtools_http_handler.h"
9#include "content/public/browser/devtools_http_handler_delegate.h"
10#include "content/public/browser/devtools_target.h"
11#include "net/socket/stream_listen_socket.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace content {
15namespace {
16
17using net::StreamListenSocket;
18
19class DummyListenSocket : public StreamListenSocket,
20                          public StreamListenSocket::Delegate {
21 public:
22  DummyListenSocket()
23      : StreamListenSocket(0, this) {}
24
25  // StreamListenSocket::Delegate "implementation"
26  virtual void DidAccept(StreamListenSocket* server,
27                         scoped_ptr<StreamListenSocket> connection) OVERRIDE {}
28  virtual void DidRead(StreamListenSocket* connection,
29                       const char* data,
30                       int len) OVERRIDE {}
31  virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
32 protected:
33  virtual ~DummyListenSocket() {}
34  virtual void Accept() OVERRIDE {}
35};
36
37class DummyListenSocketFactory : public net::StreamListenSocketFactory {
38 public:
39  DummyListenSocketFactory(
40      base::Closure quit_closure_1, base::Closure quit_closure_2)
41      : quit_closure_1_(quit_closure_1), quit_closure_2_(quit_closure_2) {}
42  virtual ~DummyListenSocketFactory() {
43    BrowserThread::PostTask(
44        BrowserThread::UI, FROM_HERE, quit_closure_2_);
45  }
46
47  virtual scoped_ptr<StreamListenSocket> CreateAndListen(
48      StreamListenSocket::Delegate* delegate) const OVERRIDE {
49    BrowserThread::PostTask(
50        BrowserThread::UI, FROM_HERE, quit_closure_1_);
51    return scoped_ptr<net::StreamListenSocket>(new DummyListenSocket());
52  }
53 private:
54  base::Closure quit_closure_1_;
55  base::Closure quit_closure_2_;
56};
57
58class DummyDelegate : public DevToolsHttpHandlerDelegate {
59 public:
60  virtual std::string GetDiscoveryPageHTML() OVERRIDE { return std::string(); }
61  virtual bool BundlesFrontendResources() OVERRIDE { return true; }
62  virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
63    return base::FilePath();
64  }
65  virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE {
66    return std::string();
67  }
68  virtual scoped_ptr<DevToolsTarget> CreateNewTarget(const GURL& url) OVERRIDE {
69    return scoped_ptr<DevToolsTarget>();
70  }
71  virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
72    callback.Run(TargetList());
73  }
74  virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
75    net::StreamListenSocket::Delegate* delegate,
76    std::string* name) OVERRIDE {
77    return scoped_ptr<net::StreamListenSocket>();
78  }
79};
80
81}
82
83class DevToolsHttpHandlerTest : public testing::Test {
84 public:
85  DevToolsHttpHandlerTest()
86      : ui_thread_(BrowserThread::UI, &message_loop_) {
87  }
88 protected:
89  virtual void SetUp() {
90    file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE));
91    file_thread_->Start();
92  }
93  virtual void TearDown() {
94    file_thread_->Stop();
95  }
96 private:
97  base::MessageLoopForIO message_loop_;
98  BrowserThreadImpl ui_thread_;
99  scoped_ptr<BrowserThreadImpl> file_thread_;
100};
101
102TEST_F(DevToolsHttpHandlerTest, TestStartStop) {
103  base::RunLoop run_loop, run_loop_2;
104  content::DevToolsHttpHandler* devtools_http_handler_ =
105      content::DevToolsHttpHandler::Start(
106          new DummyListenSocketFactory(run_loop.QuitClosure(),
107                                       run_loop_2.QuitClosure()),
108          std::string(),
109          new DummyDelegate());
110  // Our dummy socket factory will post a quit message once the server will
111  // become ready.
112  run_loop.Run();
113  devtools_http_handler_->Stop();
114  // Make sure the handler actually stops.
115  run_loop_2.Run();
116}
117
118}  // namespace content
119