Rename shell.mojom to connector.mojom, ApplicationManager to Shell

mojo/shell/background/background_shell.cc

 // Copyright 2016 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 "mojo/shell/background/background_shell.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/services/package_manager/package_manager.h"
-#include "mojo/shell/application_manager.h"
 #include "mojo/shell/connect_params.h"
 #include "mojo/shell/loader.h"
 #include "mojo/shell/public/cpp/shell_client.h"
 #include "mojo/shell/public/cpp/shell_connection.h"
+#include "mojo/shell/shell.h"
 #include "mojo/shell/standalone/context.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 scoped_ptr<base::MessagePump> CreateMessagePumpMojo() {
   return make_scoped_ptr(new common::MessagePumpMojo);
 }
 
@@ skipping 43 matching lines @@
       : SimpleThread("mojo-background-shell"),
         init_params_(std::move(init_params)) {}
   ~MojoThread() override {}
 
   void CreateShellClientRequest(base::WaitableEvent* signal,
                                 scoped_ptr<ConnectParams> params,
                                 mojom::ShellClientRequest* request) {
     // Only valid to call this on the background thread.
     DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
-    // Ownership of |loader| passes to ApplicationManager.
+    // Ownership of |loader| passes to Shell.
     const std::string name = params->target().name();
     BackgroundLoader* loader = new BackgroundLoader(
         base::Bind(&MojoThread::OnGotApplicationRequest, base::Unretained(this),
                    name, signal, request));
-    context_->application_manager()->SetLoaderForName(make_scoped_ptr(loader),
-                                                      name);
-    context_->application_manager()->Connect(std::move(params));
+    context_->shell()->SetLoaderForName(make_scoped_ptr(loader), name);
+    context_->shell()->Connect(std::move(params));
     // The request is asynchronously processed. When processed
     // OnGotApplicationRequest() is called and we'll signal |signal|.
   }
 
   base::MessageLoop* message_loop() { return message_loop_; }
 
   // Stops the background thread.
   void Stop() {
     DCHECK_NE(message_loop_, base::MessageLoop::current());
     message_loop_->task_runner()->PostTask(
@@ skipping 37 matching lines @@
     context_ = nullptr;
   }
 
  private:
   void OnGotApplicationRequest(const std::string& name,
                                base::WaitableEvent* signal,
                                mojom::ShellClientRequest* request_result,
                                mojom::ShellClientRequest actual_request) {
     *request_result = std::move(actual_request);
     // Trigger destruction of the loader.
-    context_->application_manager()->SetLoaderForName(nullptr, name);
+    context_->shell()->SetLoaderForName(nullptr, name);
     signal->Signal();
   }
 
   // We own this. It's created on the main thread, but destroyed on the
   // background thread.
   MojoMessageLoop* message_loop_ = nullptr;
   // Created in Run() on the background thread.
   Context* context_ = nullptr;
 
   scoped_ptr<BackgroundShell::InitParams> init_params_;
@@ skipping 26 matching lines @@
   thread_->message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&MojoThread::CreateShellClientRequest,
                             base::Unretained(thread_.get()), &signal,
                             base::Passed(&params), &request));
   signal.Wait();
   return request;
 }
 
 }  // namespace shell
 }  // namespace mojo