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.
5 #include "base/file_util.h"
6 #include "base/files/scoped_temp_dir.h"
7 #include "base/message_loop/message_loop.h"
8 #include "base/run_loop.h"
9 #include "base/strings/string_number_conversions.h"
10 #include "content/browser/browser_thread_impl.h"
11 #include "content/public/browser/devtools_http_handler.h"
12 #include "content/public/browser/devtools_http_handler_delegate.h"
13 #include "content/public/browser/devtools_target.h"
14 #include "net/base/ip_endpoint.h"
15 #include "net/base/net_errors.h"
16 #include "net/socket/server_socket.h"
17 #include "testing/gtest/include/gtest/gtest.h"
22 const int kDummyPort
= 4321;
23 const base::FilePath::CharType kDevToolsActivePortFileName
[] =
24 FILE_PATH_LITERAL("DevToolsActivePort");
26 class DummyServerSocket
: public net::ServerSocket
{
28 DummyServerSocket() {}
30 // net::ServerSocket "implementation"
31 virtual int Listen(const net::IPEndPoint
& address
, int backlog
) OVERRIDE
{
35 virtual int ListenWithAddressAndPort(const std::string
& ip_address
,
37 int backlog
) OVERRIDE
{
41 virtual int GetLocalAddress(net::IPEndPoint
* address
) const OVERRIDE
{
42 net::IPAddressNumber number
;
43 EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &number
));
44 *address
= net::IPEndPoint(number
, kDummyPort
);
48 virtual int Accept(scoped_ptr
<net::StreamSocket
>* socket
,
49 const net::CompletionCallback
& callback
) OVERRIDE
{
50 return net::ERR_IO_PENDING
;
54 class DummyServerSocketFactory
55 : public DevToolsHttpHandler::ServerSocketFactory
{
57 DummyServerSocketFactory(base::Closure quit_closure_1
,
58 base::Closure quit_closure_2
)
59 : DevToolsHttpHandler::ServerSocketFactory("", 0, 0),
60 quit_closure_1_(quit_closure_1
),
61 quit_closure_2_(quit_closure_2
) {}
63 virtual ~DummyServerSocketFactory() {
64 BrowserThread::PostTask(
65 BrowserThread::UI
, FROM_HERE
, quit_closure_2_
);
69 virtual scoped_ptr
<net::ServerSocket
> Create() const OVERRIDE
{
70 BrowserThread::PostTask(
71 BrowserThread::UI
, FROM_HERE
, quit_closure_1_
);
72 return scoped_ptr
<net::ServerSocket
>(new DummyServerSocket());
75 base::Closure quit_closure_1_
;
76 base::Closure quit_closure_2_
;
79 class DummyDelegate
: public DevToolsHttpHandlerDelegate
{
81 virtual std::string
GetDiscoveryPageHTML() OVERRIDE
{ return std::string(); }
83 virtual bool BundlesFrontendResources() OVERRIDE
{ return true; }
85 virtual base::FilePath
GetDebugFrontendDir() OVERRIDE
{
86 return base::FilePath();
89 virtual std::string
GetPageThumbnailData(const GURL
& url
) OVERRIDE
{
93 virtual scoped_ptr
<DevToolsTarget
> CreateNewTarget(const GURL
& url
) OVERRIDE
{
94 return scoped_ptr
<DevToolsTarget
>();
97 virtual void EnumerateTargets(TargetCallback callback
) OVERRIDE
{
98 callback
.Run(TargetList());
101 virtual scoped_ptr
<net::StreamListenSocket
> CreateSocketForTethering(
102 net::StreamListenSocket::Delegate
* delegate
,
103 std::string
* name
) OVERRIDE
{
104 return scoped_ptr
<net::StreamListenSocket
>();
110 class DevToolsHttpHandlerTest
: public testing::Test
{
112 DevToolsHttpHandlerTest()
113 : ui_thread_(BrowserThread::UI
, &message_loop_
) {
117 virtual void SetUp() {
118 file_thread_
.reset(new BrowserThreadImpl(BrowserThread::FILE));
119 file_thread_
->Start();
122 virtual void TearDown() {
123 file_thread_
->Stop();
127 base::MessageLoopForIO message_loop_
;
128 BrowserThreadImpl ui_thread_
;
129 scoped_ptr
<BrowserThreadImpl
> file_thread_
;
132 TEST_F(DevToolsHttpHandlerTest
, TestStartStop
) {
133 base::RunLoop run_loop
, run_loop_2
;
134 scoped_ptr
<DevToolsHttpHandler::ServerSocketFactory
> factory(
135 new DummyServerSocketFactory(run_loop
.QuitClosure(),
136 run_loop_2
.QuitClosure()));
137 content::DevToolsHttpHandler
* devtools_http_handler_
=
138 content::DevToolsHttpHandler::Start(factory
.Pass(),
142 // Our dummy socket factory will post a quit message once the server will
145 devtools_http_handler_
->Stop();
146 // Make sure the handler actually stops.
150 TEST_F(DevToolsHttpHandlerTest
, TestDevToolsActivePort
) {
151 base::RunLoop run_loop
, run_loop_2
;
152 base::ScopedTempDir temp_dir
;
153 EXPECT_TRUE(temp_dir
.CreateUniqueTempDir());
154 scoped_ptr
<DevToolsHttpHandler::ServerSocketFactory
> factory(
155 new DummyServerSocketFactory(run_loop
.QuitClosure(),
156 run_loop_2
.QuitClosure()));
157 content::DevToolsHttpHandler
* devtools_http_handler_
=
158 content::DevToolsHttpHandler::Start(factory
.Pass(),
162 // Our dummy socket factory will post a quit message once the server will
165 devtools_http_handler_
->Stop();
166 // Make sure the handler actually stops.
169 // Now make sure the DevToolsActivePort was written into the
170 // temporary directory and its contents are as expected.
171 base::FilePath active_port_file
= temp_dir
.path().Append(
172 kDevToolsActivePortFileName
);
173 EXPECT_TRUE(base::PathExists(active_port_file
));
174 std::string file_contents
;
175 EXPECT_TRUE(base::ReadFileToString(active_port_file
, &file_contents
));
177 EXPECT_TRUE(base::StringToInt(file_contents
, &port
));
178 EXPECT_EQ(kDummyPort
, port
);
181 } // namespace content