Add assertions to ensure that only one instance of RemoteTestServer is

net/test/spawned_test_server/remote_test_server.cc

 // Copyright 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 "net/test/spawned_test_server/remote_test_server.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/test/spawned_test_server/spawner_communicator.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
+// Based on how the Android runner sets things up, it is only valid for one
+// RemoteTestServer to be active on the device at a time.
+class RemoteTestServerTracker {
+ public:
+  void StartingServer() {
+    base::AutoLock l(lock_);
+    CHECK_EQ(count_, 0);
+    count_++;
+  }
+
+  void StoppingServer() {
+    base::AutoLock l(lock_);
+    CHECK_EQ(count_, 1);
+    count_--;
+  }
+
+ private:
+  // |lock_| protects access to |count_|.
+  base::Lock lock_;
+  int count_ = 0;
+};
+
+base::LazyInstance<RemoteTestServerTracker>::Leaky tracker =
+    LAZY_INSTANCE_INITIALIZER;
+
 // To reduce the running time of tests, tests may be sharded across several
 // devices. This means that it may be necessary to support multiple instances
 // of the test server spawner and the Python test server simultaneously on the
 // same host. Each pair of (test server spawner, Python test server) correspond
 // to a single testing device.
 // The mapping between the test server spawner and the individual Python test
 // servers is written to a file on the device prior to executing any tests.
 base::FilePath GetTestServerPortInfoFile() {
 #if !defined(OS_ANDROID)
   return base::FilePath("/tmp/net-test-server-ports");
@@ skipping 45 matching lines @@
     NOTREACHED();
 }
 
 RemoteTestServer::~RemoteTestServer() {
   Stop();
 }
 
 bool RemoteTestServer::Start() {
   if (spawner_communicator_.get())
     return true;
+
+  tracker.Get().StartingServer();
+
   spawner_communicator_.reset(new SpawnerCommunicator(spawner_server_port_));
 
   base::DictionaryValue arguments_dict;
   if (!GenerateArguments(&arguments_dict))
     return false;
 
   arguments_dict.Set("on-remote-server", base::Value::CreateNullValue());
 
   // Append the 'server-type' argument which is used by spawner server to
   // pass right server type to Python test server.
@@ skipping 36 matching lines @@
 }
 
 bool RemoteTestServer::BlockUntilStarted() {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool RemoteTestServer::Stop() {
   if (!spawner_communicator_.get())
     return true;
+
+  tracker.Get().StoppingServer();
+
   CleanUpWhenStoppingServer();
   bool stopped = spawner_communicator_->StopServer();
+
+  if (!stopped)
+    LOG(ERROR) << "Failed stopping RemoteTestServer";
+
   // Explicitly reset |spawner_communicator_| to avoid reusing the stopped one.
   spawner_communicator_.reset(NULL);
   return stopped;
 }
 
 // On Android, the document root in the device is not the same as the document
 // root in the host machine where the test server is launched. So prepend
 // DIR_SOURCE_ROOT here to get the actual path of document root on the Android
 // device.
 base::FilePath RemoteTestServer::GetDocumentRoot() const {
@@ skipping 43 matching lines @@
     fixed_root = base::FilePath(base::FilePath::kCurrentDirectory);
   SetResourcePath(fixed_root, base::FilePath().AppendASCII("net")
                                            .AppendASCII("data")
                                            .AppendASCII("ssl")
                                            .AppendASCII("certificates"));
   return true;
 }
 
 }  // namespace net