ShellClient -> Service

chrome/browser/devtools/device/adb/mock_adb_server.cc

 // Copyright 2014 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/browser/devtools/device/adb/mock_adb_server.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/location.h"
@@ skipping 201 matching lines @@
     std::unique_ptr<Parser> parser_;
     scoped_refptr<net::GrowableIOBuffer> input_buffer_;
     scoped_refptr<net::GrowableIOBuffer> output_buffer_;
     int bytes_to_write_;
     bool read_closed_;
     base::WeakPtrFactory<Connection> weak_factory_;
 
     DISALLOW_COPY_AND_ASSIGN(Connection);
   };
 
-  void AcceptConnection();
+  void OnConnect();
   void OnAccepted(int result);
 
   ParserFactory factory_;
   std::unique_ptr<net::TCPServerSocket> socket_;
   std::unique_ptr<net::StreamSocket> client_socket_;
   base::WeakPtrFactory<SimpleHttpServer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleHttpServer);
 };
 
 SimpleHttpServer::SimpleHttpServer(const ParserFactory& factory,
                                    net::IPEndPoint endpoint)
     : factory_(factory),
       socket_(new net::TCPServerSocket(nullptr, net::NetLog::Source())),
       weak_factory_(this) {
   socket_->Listen(endpoint, 5);
-  AcceptConnection();
+  OnConnect();
 }
 
 SimpleHttpServer::~SimpleHttpServer() {
 }
 
 SimpleHttpServer::Connection::Connection(net::StreamSocket* socket,
                                          const ParserFactory& factory)
     : socket_(socket),
       parser_(factory.Run(base::Bind(&Connection::Send,
                                      base::Unretained(this)))),
@@ skipping 107 matching lines @@
 
   if (bytes_to_write_ != 0)
     // Posting to avoid deep recursion in case of synchronous IO
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&Connection::WriteData, weak_factory_.GetWeakPtr()));
   else if (read_closed_)
     delete this;
 }
 
-void SimpleHttpServer::AcceptConnection() {
+void SimpleHttpServer::OnConnect() {
   CHECK(CalledOnValidThread());
 
   int accept_result = socket_->Accept(&client_socket_,
       base::Bind(&SimpleHttpServer::OnAccepted, base::Unretained(this)));
 
   if (accept_result != net::ERR_IO_PENDING)
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&SimpleHttpServer::OnAccepted,
                               weak_factory_.GetWeakPtr(), accept_result));
 }
 
 void SimpleHttpServer::OnAccepted(int result) {
   CHECK(CalledOnValidThread());
   ASSERT_EQ(result, 0);  // Fails if the socket is already in use.
   new Connection(client_socket_.release(), factory_);
-  AcceptConnection();
+  OnConnect();
 }
 
 class AdbParser : public SimpleHttpServer::Parser,
                   public base::NonThreadSafe,
                   public MockAndroidConnection::Delegate {
  public:
   static Parser* Create(FlushMode flush_mode,
                         const SimpleHttpServer::SendCallback& callback) {
     return new AdbParser(flush_mode, callback);
   }
@@ skipping 217 matching lines @@
   content::RunMessageLoop();
 }
 
 void StopMockAdbServer() {
   BrowserThread::PostTaskAndReply(BrowserThread::IO, FROM_HERE,
                                   base::Bind(&StopMockAdbServerOnIOThread),
                                   base::MessageLoop::QuitWhenIdleClosure());
   content::RunMessageLoop();
 }