OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/file_util.h" | 5 #include "base/file_util.h" |
6 #include "base/files/scoped_temp_dir.h" | 6 #include "base/files/scoped_temp_dir.h" |
7 #include "base/message_loop/message_loop.h" | 7 #include "base/message_loop/message_loop.h" |
8 #include "base/run_loop.h" | 8 #include "base/run_loop.h" |
9 #include "base/strings/string_number_conversions.h" | 9 #include "base/strings/string_number_conversions.h" |
10 #include "content/browser/browser_thread_impl.h" | 10 #include "content/browser/browser_thread_impl.h" |
11 #include "content/public/browser/devtools_http_handler.h" | 11 #include "content/public/browser/devtools_http_handler.h" |
12 #include "content/public/browser/devtools_http_handler_delegate.h" | 12 #include "content/public/browser/devtools_http_handler_delegate.h" |
13 #include "content/public/browser/devtools_target.h" | 13 #include "content/public/browser/devtools_target.h" |
14 #include "net/base/ip_endpoint.h" | 14 #include "net/base/ip_endpoint.h" |
15 #include "net/base/net_errors.h" | 15 #include "net/base/net_errors.h" |
16 #include "net/socket/stream_listen_socket.h" | 16 #include "net/socket/server_socket.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
18 | 18 |
19 namespace content { | 19 namespace content { |
20 namespace { | 20 namespace { |
21 | 21 |
22 const int kDummyPort = 4321; | 22 const int kDummyPort = 4321; |
23 const base::FilePath::CharType kDevToolsActivePortFileName[] = | 23 const base::FilePath::CharType kDevToolsActivePortFileName[] = |
24 FILE_PATH_LITERAL("DevToolsActivePort"); | 24 FILE_PATH_LITERAL("DevToolsActivePort"); |
25 | 25 |
26 using net::StreamListenSocket; | 26 class DummyServerSocket : public net::ServerSocket { |
| 27 public: |
| 28 DummyServerSocket() {} |
27 | 29 |
28 class DummyListenSocket : public StreamListenSocket, | 30 // net::ServerSocket "implementation" |
29 public StreamListenSocket::Delegate { | 31 virtual int Listen(const net::IPEndPoint& address, int backlog) OVERRIDE { |
30 public: | 32 return net::OK; |
31 DummyListenSocket() | 33 } |
32 : StreamListenSocket(net::kInvalidSocket, this) {} | |
33 | 34 |
34 // StreamListenSocket::Delegate "implementation" | 35 virtual int ListenWithAddressAndPort(const std::string& ip_address, |
35 virtual void DidAccept(StreamListenSocket* server, | 36 int port, |
36 scoped_ptr<StreamListenSocket> connection) OVERRIDE {} | 37 int backlog) OVERRIDE { |
37 virtual void DidRead(StreamListenSocket* connection, | 38 return net::OK; |
38 const char* data, | 39 } |
39 int len) OVERRIDE {} | 40 |
40 virtual void DidClose(StreamListenSocket* sock) OVERRIDE {} | 41 virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE { |
41 protected: | |
42 virtual ~DummyListenSocket() {} | |
43 virtual void Accept() OVERRIDE {} | |
44 virtual int GetLocalAddress(net::IPEndPoint* address) OVERRIDE { | |
45 net::IPAddressNumber number; | 42 net::IPAddressNumber number; |
46 EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &number)); | 43 EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &number)); |
47 *address = net::IPEndPoint(number, kDummyPort); | 44 *address = net::IPEndPoint(number, kDummyPort); |
48 return net::OK; | 45 return net::OK; |
49 } | 46 } |
| 47 |
| 48 virtual int Accept(scoped_ptr<net::StreamSocket>* socket, |
| 49 const net::CompletionCallback& callback) OVERRIDE { |
| 50 return net::ERR_IO_PENDING; |
| 51 } |
50 }; | 52 }; |
51 | 53 |
52 class DummyListenSocketFactory : public net::StreamListenSocketFactory { | 54 class DummyServerSocketFactory |
| 55 : public DevToolsHttpHandler::ServerSocketFactory { |
53 public: | 56 public: |
54 DummyListenSocketFactory( | 57 DummyServerSocketFactory(base::Closure quit_closure_1, |
55 base::Closure quit_closure_1, base::Closure quit_closure_2) | 58 base::Closure quit_closure_2) |
56 : quit_closure_1_(quit_closure_1), quit_closure_2_(quit_closure_2) {} | 59 : DevToolsHttpHandler::ServerSocketFactory("", 0, 0), |
57 virtual ~DummyListenSocketFactory() { | 60 quit_closure_1_(quit_closure_1), |
| 61 quit_closure_2_(quit_closure_2) {} |
| 62 |
| 63 virtual ~DummyServerSocketFactory() { |
58 BrowserThread::PostTask( | 64 BrowserThread::PostTask( |
59 BrowserThread::UI, FROM_HERE, quit_closure_2_); | 65 BrowserThread::UI, FROM_HERE, quit_closure_2_); |
60 } | 66 } |
61 | 67 |
62 virtual scoped_ptr<StreamListenSocket> CreateAndListen( | 68 private: |
63 StreamListenSocket::Delegate* delegate) const OVERRIDE { | 69 virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE { |
64 BrowserThread::PostTask( | 70 BrowserThread::PostTask( |
65 BrowserThread::UI, FROM_HERE, quit_closure_1_); | 71 BrowserThread::UI, FROM_HERE, quit_closure_1_); |
66 return scoped_ptr<net::StreamListenSocket>(new DummyListenSocket()); | 72 return scoped_ptr<net::ServerSocket>(new DummyServerSocket()); |
67 } | 73 } |
68 private: | 74 |
69 base::Closure quit_closure_1_; | 75 base::Closure quit_closure_1_; |
70 base::Closure quit_closure_2_; | 76 base::Closure quit_closure_2_; |
71 }; | 77 }; |
72 | 78 |
73 class DummyDelegate : public DevToolsHttpHandlerDelegate { | 79 class DummyDelegate : public DevToolsHttpHandlerDelegate { |
74 public: | 80 public: |
75 virtual std::string GetDiscoveryPageHTML() OVERRIDE { return std::string(); } | 81 virtual std::string GetDiscoveryPageHTML() OVERRIDE { return std::string(); } |
| 82 |
76 virtual bool BundlesFrontendResources() OVERRIDE { return true; } | 83 virtual bool BundlesFrontendResources() OVERRIDE { return true; } |
| 84 |
77 virtual base::FilePath GetDebugFrontendDir() OVERRIDE { | 85 virtual base::FilePath GetDebugFrontendDir() OVERRIDE { |
78 return base::FilePath(); | 86 return base::FilePath(); |
79 } | 87 } |
| 88 |
80 virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE { | 89 virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE { |
81 return std::string(); | 90 return std::string(); |
82 } | 91 } |
| 92 |
83 virtual scoped_ptr<DevToolsTarget> CreateNewTarget(const GURL& url) OVERRIDE { | 93 virtual scoped_ptr<DevToolsTarget> CreateNewTarget(const GURL& url) OVERRIDE { |
84 return scoped_ptr<DevToolsTarget>(); | 94 return scoped_ptr<DevToolsTarget>(); |
85 } | 95 } |
| 96 |
86 virtual void EnumerateTargets(TargetCallback callback) OVERRIDE { | 97 virtual void EnumerateTargets(TargetCallback callback) OVERRIDE { |
87 callback.Run(TargetList()); | 98 callback.Run(TargetList()); |
88 } | 99 } |
| 100 |
89 virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering( | 101 virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering( |
90 net::StreamListenSocket::Delegate* delegate, | 102 net::StreamListenSocket::Delegate* delegate, |
91 std::string* name) OVERRIDE { | 103 std::string* name) OVERRIDE { |
92 return scoped_ptr<net::StreamListenSocket>(); | 104 return scoped_ptr<net::StreamListenSocket>(); |
93 } | 105 } |
94 }; | 106 }; |
95 | 107 |
96 } | 108 } |
97 | 109 |
98 class DevToolsHttpHandlerTest : public testing::Test { | 110 class DevToolsHttpHandlerTest : public testing::Test { |
99 public: | 111 public: |
100 DevToolsHttpHandlerTest() | 112 DevToolsHttpHandlerTest() |
101 : ui_thread_(BrowserThread::UI, &message_loop_) { | 113 : ui_thread_(BrowserThread::UI, &message_loop_) { |
102 } | 114 } |
| 115 |
103 protected: | 116 protected: |
104 virtual void SetUp() { | 117 virtual void SetUp() { |
105 file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE)); | 118 file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE)); |
106 file_thread_->Start(); | 119 file_thread_->Start(); |
107 } | 120 } |
| 121 |
108 virtual void TearDown() { | 122 virtual void TearDown() { |
109 file_thread_->Stop(); | 123 file_thread_->Stop(); |
110 } | 124 } |
| 125 |
111 private: | 126 private: |
112 base::MessageLoopForIO message_loop_; | 127 base::MessageLoopForIO message_loop_; |
113 BrowserThreadImpl ui_thread_; | 128 BrowserThreadImpl ui_thread_; |
114 scoped_ptr<BrowserThreadImpl> file_thread_; | 129 scoped_ptr<BrowserThreadImpl> file_thread_; |
115 }; | 130 }; |
116 | 131 |
117 TEST_F(DevToolsHttpHandlerTest, TestStartStop) { | 132 TEST_F(DevToolsHttpHandlerTest, TestStartStop) { |
118 base::RunLoop run_loop, run_loop_2; | 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())); |
119 content::DevToolsHttpHandler* devtools_http_handler_ = | 137 content::DevToolsHttpHandler* devtools_http_handler_ = |
120 content::DevToolsHttpHandler::Start( | 138 content::DevToolsHttpHandler::Start(factory.Pass(), |
121 new DummyListenSocketFactory(run_loop.QuitClosure(), | 139 std::string(), |
122 run_loop_2.QuitClosure()), | 140 new DummyDelegate(), |
123 std::string(), | 141 base::FilePath()); |
124 new DummyDelegate(), | |
125 base::FilePath()); | |
126 // Our dummy socket factory will post a quit message once the server will | 142 // Our dummy socket factory will post a quit message once the server will |
127 // become ready. | 143 // become ready. |
128 run_loop.Run(); | 144 run_loop.Run(); |
129 devtools_http_handler_->Stop(); | 145 devtools_http_handler_->Stop(); |
130 // Make sure the handler actually stops. | 146 // Make sure the handler actually stops. |
131 run_loop_2.Run(); | 147 run_loop_2.Run(); |
132 } | 148 } |
133 | 149 |
134 TEST_F(DevToolsHttpHandlerTest, TestDevToolsActivePort) { | 150 TEST_F(DevToolsHttpHandlerTest, TestDevToolsActivePort) { |
135 base::RunLoop run_loop, run_loop_2; | 151 base::RunLoop run_loop, run_loop_2; |
136 base::ScopedTempDir temp_dir; | 152 base::ScopedTempDir temp_dir; |
137 EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); | 153 EXPECT_TRUE(temp_dir.CreateUniqueTempDir()); |
| 154 scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory( |
| 155 new DummyServerSocketFactory(run_loop.QuitClosure(), |
| 156 run_loop_2.QuitClosure())); |
138 content::DevToolsHttpHandler* devtools_http_handler_ = | 157 content::DevToolsHttpHandler* devtools_http_handler_ = |
139 content::DevToolsHttpHandler::Start( | 158 content::DevToolsHttpHandler::Start(factory.Pass(), |
140 new DummyListenSocketFactory(run_loop.QuitClosure(), | 159 std::string(), |
141 run_loop_2.QuitClosure()), | 160 new DummyDelegate(), |
142 std::string(), | 161 temp_dir.path()); |
143 new DummyDelegate(), | |
144 temp_dir.path()); | |
145 // Our dummy socket factory will post a quit message once the server will | 162 // Our dummy socket factory will post a quit message once the server will |
146 // become ready. | 163 // become ready. |
147 run_loop.Run(); | 164 run_loop.Run(); |
148 devtools_http_handler_->Stop(); | 165 devtools_http_handler_->Stop(); |
149 // Make sure the handler actually stops. | 166 // Make sure the handler actually stops. |
150 run_loop_2.Run(); | 167 run_loop_2.Run(); |
151 | 168 |
152 // Now make sure the DevToolsActivePort was written into the | 169 // Now make sure the DevToolsActivePort was written into the |
153 // temporary directory and its contents are as expected. | 170 // temporary directory and its contents are as expected. |
154 base::FilePath active_port_file = temp_dir.path().Append( | 171 base::FilePath active_port_file = temp_dir.path().Append( |
155 kDevToolsActivePortFileName); | 172 kDevToolsActivePortFileName); |
156 EXPECT_TRUE(base::PathExists(active_port_file)); | 173 EXPECT_TRUE(base::PathExists(active_port_file)); |
157 std::string file_contents; | 174 std::string file_contents; |
158 EXPECT_TRUE(base::ReadFileToString(active_port_file, &file_contents)); | 175 EXPECT_TRUE(base::ReadFileToString(active_port_file, &file_contents)); |
159 int port = 0; | 176 int port = 0; |
160 EXPECT_TRUE(base::StringToInt(file_contents, &port)); | 177 EXPECT_TRUE(base::StringToInt(file_contents, &port)); |
161 EXPECT_EQ(kDummyPort, port); | 178 EXPECT_EQ(kDummyPort, port); |
162 } | 179 } |
163 | 180 |
164 } // namespace content | 181 } // namespace content |
OLD | NEW |