[chromedriver] Reuse forwarded adb ports.

chrome/test/chromedriver/net/port_server.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/test/chromedriver/net/port_server.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/process/process_handle.h"
@@ skipping 123 matching lines @@
   free_.push_back(port);
 }
 
 PortManager::PortManager(int min_port, int max_port)
     : min_port_(min_port), max_port_(max_port) {
   CHECK_GE(max_port_, min_port_);
 }
 
 PortManager::~PortManager() {}
 
-Status PortManager::ReservePort(int* port,
-                                scoped_ptr<PortReservation>* reservation) {
-  base::AutoLock lock(taken_lock_);
-
+int PortManager::FindAvailablePort() const {
   int start = base::RandInt(min_port_, max_port_);
   bool wrapped = false;
   for (int try_port = start; try_port != start || !wrapped; ++try_port) {
     if (try_port > max_port_) {
       wrapped = true;
       if (min_port_ == max_port_)
         break;
       try_port = min_port_;
     }
     if (taken_.count(try_port))

[chrisgao (Use stgao instead), 2014/01/14 02:11:46]

Maybe it is good to add a comment in port_server.h saying |lock_| should be held
before calling PortManager::FindAvailablePort?

       continue;

[chrisgao (Use stgao instead), 2014/01/14 02:11:46]

In a corner case, chromedriver is used to test on both desktop version and
android version.
For the desktop version, if |try_port| is in |unused_forwarded_port_|, we could
assume it is used by adb and skip it too?

 
     char parts[] = {127, 0, 0, 1};
     net::IPAddressNumber address(parts, parts + arraysize(parts));
     net::NetLog::Source source;
     net::TCPServerSocket sock(NULL, source);
-    if (sock.Listen(net::IPEndPoint(address, try_port), 1) != net::OK)
-      continue;
+    if (sock.Listen(net::IPEndPoint(address, try_port), 1) == net::OK)
+      return try_port;
+  }
+  return 0;
+}
 
-    taken_.insert(try_port);
-    *port = try_port;
-    reservation->reset(new PortReservation(
-        base::Bind(&PortManager::ReleasePort, base::Unretained(this), try_port),
-        try_port));
-    return Status(kOk);
+Status PortManager::ReservePort(int* port,
+                                scoped_ptr<PortReservation>* reservation) {
+  base::AutoLock lock(lock_);
+  int port_to_use = FindAvailablePort();
+  if (!port_to_use)
+    return Status(kUnknownError, "unable to find open port");
+
+  taken_.insert(port_to_use);
+  *port = port_to_use;
+  reservation->reset(new PortReservation(
+      base::Bind(&PortManager::ReleasePort, base::Unretained(this),
+                 port_to_use),
+      port_to_use));
+  return Status(kOk);
+}
+
+Status PortManager::ReservePortFromPool(
+    int* port, scoped_ptr<PortReservation>* reservation) {
+  base::AutoLock lock(lock_);
+  int port_to_use = 0;
+  if (unused_forwarded_port_.size()) {
+    port_to_use = unused_forwarded_port_.front();
+    unused_forwarded_port_.pop_front();
+  } else {
+    port_to_use = FindAvailablePort();
   }
-  return Status(kUnknownError, "unable to find open port");
+  if (!port_to_use)
+    return Status(kUnknownError, "unable to find open port");
+
+  taken_.insert(port_to_use);
+  *port = port_to_use;
+  reservation->reset(new PortReservation(
+      base::Bind(&PortManager::ReleasePortToPool, base::Unretained(this),
+                 port_to_use),
+      port_to_use));
+  return Status(kOk);
 }
 
 void PortManager::ReleasePort(int port) {
-  base::AutoLock lock(taken_lock_);
+  base::AutoLock lock(lock_);
   taken_.erase(port);
 }
+
+void PortManager::ReleasePortToPool(int port) {
+  base::AutoLock lock(lock_);
+  taken_.erase(port);
+  unused_forwarded_port_.push_back(port);
+}