ApplicationImpl->ShellConnection, mojom::Application->mojom::ShellClient

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/shell/application_loader.h"
 #include "mojo/shell/application_manager.h"
 #include "mojo/shell/capability_filter.h"
 #include "mojo/shell/connect_to_application_params.h"
-#include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/shell_client.h"
+#include "mojo/shell/public/cpp/shell_connection.h"
 #include "mojo/shell/standalone/context.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 scoped_ptr<base::MessagePump> CreateMessagePumpMojo() {
   return make_scoped_ptr(new common::MessagePumpMojo);
 }
 
 // Used to obtain the InterfaceRequest for an application.
 class BackgroundApplicationLoader : public ApplicationLoader {
  public:
   BackgroundApplicationLoader() {}
   ~BackgroundApplicationLoader() override {}
 
   bool got_request() const { return got_request_; }
-  InterfaceRequest<mojom::Application> TakeApplicationRequest() {
-    return std::move(application_request_);
+  InterfaceRequest<mojom::ShellClient> TakeApplicationRequest() {
+    return std::move(request_);
   }
 
   // ApplicationLoader:
   void Load(const GURL& url,
-            InterfaceRequest<mojom::Application> application_request) override {
+            InterfaceRequest<mojom::ShellClient> request) override {
     got_request_ = true;
-    application_request_ = std::move(application_request);
+    request_ = std::move(request);
   }
 
  private:
   bool got_request_ = false;
-  InterfaceRequest<mojom::Application> application_request_;
+  InterfaceRequest<mojom::ShellClient> request_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundApplicationLoader);
 };
 
 class MojoMessageLoop : public base::MessageLoop {
  public:
   MojoMessageLoop()
       : base::MessageLoop(base::MessageLoop::TYPE_CUSTOM,
                           base::Bind(&CreateMessagePumpMojo)) {}
   ~MojoMessageLoop() override {}
 
   void BindToCurrentThread() { base::MessageLoop::BindToCurrentThread(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MojoMessageLoop);
 };
 
 }  // namespace
 
 // Manages the thread to startup mojo.
 class BackgroundShell::MojoThread : public base::SimpleThread {
  public:
   MojoThread() : SimpleThread("mojo-background-shell") {}
   ~MojoThread() override {}
 
-  void CreateApplicationImpl(base::WaitableEvent* signal,
-                             scoped_ptr<ConnectToApplicationParams> params,
-                             InterfaceRequest<mojom::Application>* request) {
+  void CreateShellClientRequest(base::WaitableEvent* signal,
+                                scoped_ptr<ConnectToApplicationParams> params,
+                                InterfaceRequest<mojom::ShellClient>* request) {
     // Only valid to call this on the background thread.
     DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
     // Ownership of |loader| passes to ApplicationManager.
     BackgroundApplicationLoader* loader = new BackgroundApplicationLoader;
     const GURL url = params->target().url();
     context_->application_manager()->SetLoaderForURL(make_scoped_ptr(loader),
                                                      url);
     context_->application_manager()->ConnectToApplication(std::move(params));
     DCHECK(loader->got_request());
@@ skipping 60 matching lines @@
 BackgroundShell::~BackgroundShell() {
   thread_->Stop();
 }
 
 void BackgroundShell::Init() {
   DCHECK(!thread_);
   thread_.reset(new MojoThread);
   thread_->Start();
 }
 
-InterfaceRequest<mojom::Application> BackgroundShell::CreateApplication(
+InterfaceRequest<mojom::ShellClient> BackgroundShell::CreateShellClientRequest(
     const GURL& url) {
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->SetTarget(
       Identity(url, std::string(), GetPermissiveCapabilityFilter()));
-  InterfaceRequest<mojom::Application> request;
+  InterfaceRequest<mojom::ShellClient> request;
   base::WaitableEvent signal(true, false);
   thread_->message_loop()->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&MojoThread::CreateApplicationImpl,
+      FROM_HERE, base::Bind(&MojoThread::CreateShellClientRequest,
                             base::Unretained(thread_.get()), &signal,
                             base::Passed(&params), &request));
   signal.Wait();
   return request;
 }
 
 void RegisterLocalAliases(PackageManagerImpl* manager) {}
 
 }  // namespace shell
 }  // namespace mojo