1 // Copyright 2013 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/strings/string_number_conversions.h" 6 #include "chrome/browser/devtools/devtools_adb_bridge.h" 7 #include "chrome/browser/ui/browser.h" 8 #include "chrome/test/base/in_process_browser_test.h" 9 #include "content/public/browser/browser_thread.h" 10 #include "content/public/test/browser_test.h" 11 #include "content/public/test/test_utils.h" 12 #include "net/base/host_port_pair.h" 13 #include "net/base/io_buffer.h" 14 #include "net/base/ip_endpoint.h" 15 #include "net/base/net_errors.h" 16 #include "net/base/net_log.h" 17 #include "net/socket/stream_socket.h" 18 #include "net/socket/tcp_server_socket.h" 19 20 const char kOpenedUnixSocketsCommand[] = "shell:cat /proc/net/unix"; 21 const char kDeviceModelCommand[] = "shell:getprop ro.product.model"; 22 const char kDumpsysCommand[] = "shell:dumpsys window policy"; 23 const char kListProcessesCommand[] = "shell:ps"; 24 const char kInstalledChromePackagesCommand[] = "shell:pm list packages"; 25 const char kDeviceModel[] = "Nexus 8"; 26 27 const char kSampleOpenedUnixSocketsWithoutBrowsers[] = 28 "Num RefCount Protocol Flags Type St Inode Path\n" 29 "00000000: 00000004 00000000" 30 " 00000000 0002 01 3328 /dev/socket/wpa_wlan0\n" 31 "00000000: 00000002 00000000" 32 " 00010000 0001 01 5394 /dev/socket/vold\n"; 33 34 const char kSampleDumpsys[] = 35 "WINDOW MANAGER POLICY STATE (dumpsys window policy)\r\n" 36 " mStable=(0,50)-(720,1184)\r\n"; 37 38 const char kSampleListProcesses[] = 39 "USER PID PPID VSIZE RSS WCHAN PC NAME\n" 40 "root 1 0 688 508 ffffffff 00000000 S /init\n"; 41 42 const char kSampleListPackages[] = "package:com.example.app"; 43 44 static const int kBufferSize = 16*1024; 45 static const int kAdbPort = 5037; 46 47 static const int kAdbMessageHeaderSize = 4; 48 49 // This is single connection server which listens on specified port and 50 // simplifies asynchronous IO. 51 // To write custom server, extend this class and implement TryProcessData 52 // method which is invoked everytime data arrives. In case of successful data 53 // processing(e.g. enough data collected already to parse client reply/request) 54 // return amount of bytes processed to throw them away from buffer 55 // To send data, SendData method should be used. This method is non-blocking 56 // and appends data to be sent to internal buffer. 57 // Since all calls are non-blocking and no callbacks are given, internal 58 // overflows may occur in case too heavy traffic. 59 // In case of heavy traffic performance may suffer because of memcpy calls. 60 class SingleConnectionServer { 61 public: 62 SingleConnectionServer(net::IPEndPoint endpoint, int buffer_size); 63 virtual ~SingleConnectionServer(); 64 65 protected: 66 virtual int TryProcessData(const char* data, int size) = 0; 67 void SendData(const char* data, int size); 68 69 private: 70 void AcceptConnection(); 71 void OnAccepted(int result); 72 73 void ReadData(); 74 void OnDataRead(int count); 75 76 void WriteData(); 77 void OnDataWritten(int count); 78 79 private: 80 int bytes_to_write_; 81 scoped_ptr<net::TCPServerSocket> server_socket_; 82 scoped_ptr<net::StreamSocket> client_socket_; 83 scoped_refptr<net::GrowableIOBuffer> input_buffer_; 84 scoped_refptr<net::GrowableIOBuffer> output_buffer_; 85 86 DISALLOW_COPY_AND_ASSIGN(SingleConnectionServer); 87 }; 88 89 SingleConnectionServer::SingleConnectionServer(net::IPEndPoint endpoint, 90 int buffer_size) 91 : bytes_to_write_(0) { 92 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 93 94 input_buffer_ = new net::GrowableIOBuffer(); 95 input_buffer_->SetCapacity(buffer_size); 96 97 output_buffer_ = new net::GrowableIOBuffer(); 98 99 server_socket_.reset(new net::TCPServerSocket(NULL, net::NetLog::Source())); 100 server_socket_->Listen(endpoint, 1); 101 102 AcceptConnection(); 103 } 104 105 SingleConnectionServer::~SingleConnectionServer() { 106 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 107 108 server_socket_.reset(); 109 110 if (client_socket_) { 111 client_socket_->Disconnect(); 112 client_socket_.reset(); 113 } 114 } 115 116 void SingleConnectionServer::SendData(const char* data, int size) { 117 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 118 119 if ((output_buffer_->offset() + bytes_to_write_ + size) > 120 output_buffer_->capacity()) { 121 // If not enough space without relocation 122 if (output_buffer_->capacity() < (bytes_to_write_ + size)) { 123 // If even buffer is not enough 124 int new_size = std::max(output_buffer_->capacity() * 2, size * 2); 125 output_buffer_->SetCapacity(new_size); 126 } 127 memmove(output_buffer_->StartOfBuffer(), 128 output_buffer_->data(), 129 bytes_to_write_); 130 output_buffer_->set_offset(0); 131 } 132 133 memcpy(output_buffer_->data() + bytes_to_write_, data, size); 134 bytes_to_write_ += size; 135 136 if (bytes_to_write_ == size) 137 // If write loop wasn't yet started, then start it 138 WriteData(); 139 } 140 141 void SingleConnectionServer::AcceptConnection() { 142 if (client_socket_) { 143 client_socket_->Disconnect(); 144 client_socket_.reset(); 145 } 146 147 int accept_result = server_socket_->Accept(&client_socket_, 148 base::Bind(&SingleConnectionServer::OnAccepted, base::Unretained(this))); 149 150 if (accept_result != net::ERR_IO_PENDING) 151 content::BrowserThread::PostTask( 152 content::BrowserThread::IO, 153 FROM_HERE, 154 base::Bind(&SingleConnectionServer::OnAccepted, 155 base::Unretained(this), 156 accept_result)); 157 } 158 159 void SingleConnectionServer::OnAccepted(int result) { 160 ASSERT_EQ(result, 0); // Fails if the socket is already in use. 161 ReadData(); 162 } 163 164 void SingleConnectionServer::ReadData() { 165 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 166 167 if (input_buffer_->RemainingCapacity() == 0) 168 input_buffer_->SetCapacity(input_buffer_->capacity() * 2); 169 170 int read_result = client_socket_->Read( 171 input_buffer_.get(), 172 input_buffer_->RemainingCapacity(), 173 base::Bind(&SingleConnectionServer::OnDataRead, base::Unretained(this))); 174 175 if (read_result != net::ERR_IO_PENDING) 176 OnDataRead(read_result); 177 } 178 179 void SingleConnectionServer::OnDataRead(int count) { 180 if (count <= 0) { 181 AcceptConnection(); 182 return; 183 } 184 185 input_buffer_->set_offset(input_buffer_->offset() + count); 186 187 int bytes_processed; 188 189 do { 190 char* data = input_buffer_->StartOfBuffer(); 191 int data_size = input_buffer_->offset(); 192 193 bytes_processed = TryProcessData(data, data_size); 194 195 if (bytes_processed) { 196 memmove(data, data + bytes_processed, data_size - bytes_processed); 197 input_buffer_->set_offset( data_size - bytes_processed); 198 } 199 } while (bytes_processed); 200 201 // Posting is needed not to enter deep recursion in case too synchronous IO 202 content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, 203 base::Bind(&SingleConnectionServer::ReadData, base::Unretained(this))); 204 } 205 206 void SingleConnectionServer::WriteData() { 207 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 208 CHECK_GE(output_buffer_->capacity(), 209 output_buffer_->offset() + bytes_to_write_) << "Overflow"; 210 211 int write_result = client_socket_->Write( 212 output_buffer_, 213 bytes_to_write_, 214 base::Bind(&SingleConnectionServer::OnDataWritten, 215 base::Unretained(this))); 216 if (write_result != net::ERR_IO_PENDING) 217 OnDataWritten(write_result); 218 } 219 220 void SingleConnectionServer::OnDataWritten(int count) { 221 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 222 if (count < 0) { 223 AcceptConnection(); 224 return; 225 } 226 227 CHECK_GT(count, 0); 228 CHECK_GE(output_buffer_->capacity(), 229 output_buffer_->offset() + bytes_to_write_) << "Overflow"; 230 231 bytes_to_write_ -= count; 232 output_buffer_->set_offset(output_buffer_->offset() + count); 233 234 if (bytes_to_write_ != 0) 235 // Posting is needed not to enter deep recursion in case too synchronous IO 236 content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, 237 base::Bind(&SingleConnectionServer::WriteData, base::Unretained(this))); 238 } 239 240 241 class MockAdbServer: public SingleConnectionServer { 242 public: 243 MockAdbServer(net::IPEndPoint endpoint, int buffer_size) 244 : SingleConnectionServer(endpoint, buffer_size) 245 {} 246 247 virtual ~MockAdbServer() {} 248 249 private: 250 virtual int TryProcessData(const char* data, int size) OVERRIDE { 251 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 252 253 if (size >= kAdbMessageHeaderSize) { 254 std::string message_header(data, kAdbMessageHeaderSize); 255 int message_size; 256 257 EXPECT_TRUE(base::HexStringToInt(message_header, &message_size)); 258 259 if (size >= message_size + kAdbMessageHeaderSize) { 260 std::string message_body(data + kAdbMessageHeaderSize, message_size ); 261 262 ProcessCommand(message_body); 263 264 return kAdbMessageHeaderSize + message_size; 265 } 266 } 267 268 return 0; 269 } 270 271 void ProcessCommand(const std::string& command) { 272 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 273 274 if (command == "host:devices") { 275 SendResponse("01498B321301A00A\tdevice\n01498B2B0D01300E\toffline"); 276 } else if (command == "host:transport:01498B321301A00A") { 277 SendResponse(""); 278 } else if (command == kDeviceModelCommand) { 279 SendResponse(kDeviceModel); 280 } else if (command == kOpenedUnixSocketsCommand) { 281 SendResponse(kSampleOpenedUnixSocketsWithoutBrowsers); 282 } else if (command == kDumpsysCommand) { 283 SendResponse(kSampleDumpsys); 284 } else if (command == kListProcessesCommand) { 285 SendResponse(kSampleListProcesses); 286 } else if (command == kInstalledChromePackagesCommand) { 287 SendResponse(kSampleListPackages); 288 } else { 289 NOTREACHED() << "Unknown command - " << command; 290 } 291 } 292 293 void SendResponse(const std::string& response) { 294 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 295 296 std::stringstream response_stream; 297 response_stream << "OKAY"; 298 299 int size = response.size(); 300 if (size > 0) { 301 static const char kHexChars[] = "0123456789ABCDEF"; 302 for (int i = 3; i >= 0; i--) 303 response_stream << kHexChars[ (size >> 4*i) & 0x0f ]; 304 response_stream << response; 305 } 306 307 std::string response_data = response_stream.str(); 308 SendData(response_data.c_str(), response_data.size()); 309 } 310 }; 311 312 class AdbClientSocketTest : public InProcessBrowserTest, 313 public DevToolsAdbBridge::Listener { 314 315 public: 316 void StartTest() { 317 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 318 319 content::BrowserThread::PostTaskAndReply( 320 content::BrowserThread::IO, 321 FROM_HERE, 322 base::Bind(&AdbClientSocketTest::StartMockAdbServer, 323 base::Unretained(this)), 324 base::Bind(&AdbClientSocketTest::AddListener, 325 base::Unretained(this))); 326 } 327 328 virtual void RemoteDevicesChanged(DevToolsAdbBridge::RemoteDevices* devices) 329 OVERRIDE { 330 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 331 adb_bridge_->RemoveListener(this); 332 devices_ = *devices; 333 EndTest(); 334 } 335 336 void CheckDevices() { 337 #if defined(DEBUG_DEVTOOLS) 338 // Mock device is added 339 ASSERT_EQ(3U, devices_.size()); 340 #else 341 ASSERT_EQ(2U, devices_.size()); 342 #endif 343 344 scoped_refptr<DevToolsAdbBridge::RemoteDevice> online_device_; 345 scoped_refptr<DevToolsAdbBridge::RemoteDevice> offline_device_; 346 347 for (DevToolsAdbBridge::RemoteDevices::const_iterator it = 348 devices_.begin(); it != devices_.end(); ++it) { 349 if ((*it)->GetSerial() == "01498B321301A00A") 350 online_device_ = *it; 351 else if ((*it)->GetSerial() == "01498B2B0D01300E") 352 offline_device_ = *it; 353 } 354 355 ASSERT_EQ(online_device_->GetSerial(), "01498B321301A00A"); 356 ASSERT_TRUE(online_device_->device()->is_connected()); 357 ASSERT_FALSE(offline_device_->device()->is_connected()); 358 359 ASSERT_EQ(online_device_->GetModel(), kDeviceModel); 360 ASSERT_EQ(online_device_->browsers().size(), 0U); 361 ASSERT_EQ(online_device_->screen_size(), gfx::Size(720, 1184)); 362 } 363 364 private: 365 void EndTest() { 366 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 367 adb_bridge_ = NULL; 368 369 content::BrowserThread::PostTaskAndReply( 370 content::BrowserThread::IO, 371 FROM_HERE, 372 base::Bind(&AdbClientSocketTest::StopMockAdbServer, 373 base::Unretained(this)), 374 base::Bind(&AdbClientSocketTest::StopMessageLoop, 375 base::Unretained(this))); 376 } 377 378 void StartMockAdbServer() { 379 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 380 net::IPAddressNumber address; 381 net::ParseIPLiteralToNumber("127.0.0.1", &address); 382 net::IPEndPoint endpoint(address, kAdbPort); 383 384 adb_server_.reset(new MockAdbServer(endpoint, kBufferSize)); 385 } 386 387 void StopMockAdbServer() { 388 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); 389 adb_server_.reset(); 390 } 391 392 void StopMessageLoop() { 393 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 394 runner->Quit(); 395 } 396 397 void AddListener() { 398 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 399 adb_bridge_ = DevToolsAdbBridge::Factory::GetForProfile( 400 browser()->profile()); 401 402 DevToolsAdbBridge::DeviceProviders device_providers; 403 device_providers.push_back(AndroidDeviceProvider::GetAdbDeviceProvider()); 404 405 adb_bridge_->set_device_providers(device_providers); 406 adb_bridge_->AddListener(this); 407 } 408 409 public: 410 scoped_refptr<content::MessageLoopRunner> runner; 411 412 private: 413 scoped_ptr<MockAdbServer> adb_server_; 414 scoped_refptr<DevToolsAdbBridge> adb_bridge_; 415 DevToolsAdbBridge::RemoteDevices devices_; 416 }; 417 418 IN_PROC_BROWSER_TEST_F(AdbClientSocketTest, TestAdbClientSocket) { 419 CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); 420 runner = new content::MessageLoopRunner; 421 422 StartTest(); 423 424 runner->Run(); 425 426 CheckDevices(); 427 } 428
