Rename a bunch of Mojo Application stuff to reference Services.

content/common/service_manager/child_connection.cc

 // Copyright 2015 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 "content/common/mojo/mojo_child_connection.h"
+#include "content/common/service_manager/child_connection.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/macros.h"
-#include "content/public/common/mojo_shell_connection.h"
+#include "content/public/common/service_manager_connection.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/identity.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "services/shell/public/interfaces/service.mojom.h"
 
 namespace content {
 
 namespace {
 
 void CallBinderOnTaskRunner(
     const shell::InterfaceRegistry::Binder& binder,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   task_runner->PostTask(
       FROM_HERE,
       base::Bind(binder, interface_name, base::Passed(&request_handle)));
 }
 
 }  // namespace
 
-class MojoChildConnection::IOThreadContext
+class ChildConnection::IOThreadContext
     : public base::RefCountedThreadSafe<IOThreadContext> {
  public:
   IOThreadContext() {}
 
   void Initialize(const shell::Identity& child_identity,
                   shell::Connector* connector,
                   mojo::ScopedMessagePipeHandle service_pipe,
                   scoped_refptr<base::SequencedTaskRunner> io_task_runner) {
     DCHECK(!io_task_runner_);
     io_task_runner_ = io_task_runner;
@@ skipping 68 matching lines @@
     pid_receiver_.reset();
   }
 
   scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
   std::unique_ptr<shell::Connection> connection_;
   shell::mojom::PIDReceiverPtr pid_receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadContext);
 };
 
-MojoChildConnection::MojoChildConnection(
+ChildConnection::ChildConnection(
     const std::string& service_name,
     const std::string& instance_id,
     const std::string& child_token,
     shell::Connector* connector,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : context_(new IOThreadContext),
       child_identity_(service_name, shell::mojom::kInheritUserID, instance_id),
       service_token_(mojo::edk::GenerateRandomToken()),
       weak_factory_(this) {
   mojo::ScopedMessagePipeHandle service_pipe =
       mojo::edk::CreateParentMessagePipe(service_token_, child_token);
 
   context_->Initialize(child_identity_, connector, std::move(service_pipe),
                        io_task_runner);
   remote_interfaces_.Forward(
       base::Bind(&CallBinderOnTaskRunner,
                  base::Bind(&IOThreadContext::GetRemoteInterfaceOnIOThread,
                             context_), io_task_runner));
 }
 
-MojoChildConnection::~MojoChildConnection() {
+ChildConnection::~ChildConnection() {
   context_->ShutDown();
 }
 
-void MojoChildConnection::SetProcessHandle(base::ProcessHandle handle) {
+void ChildConnection::SetProcessHandle(base::ProcessHandle handle) {
   context_->SetProcessHandle(handle);
 }
 
 }  // namespace content