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

mojo/shell/application_manager_unittest.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 "mojo/shell/application_manager.h"
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/connect_util.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/package_manager.h"
-#include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
 #include "mojo/shell/public/cpp/shell_client.h"
+#include "mojo/shell/public/cpp/shell_connection.h"
 #include "mojo/shell/public/interfaces/service_provider.mojom.h"
 #include "mojo/shell/test.mojom.h"
 #include "mojo/shell/test_package_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace test {
 
 const char kTestURLString[] = "test:testService";
@@ skipping 63 matching lines @@
 class TestApplicationLoader : public ApplicationLoader,
                               public ShellClient,
                               public InterfaceFactory<TestService> {
  public:
   TestApplicationLoader()
       : context_(nullptr), num_loads_(0) {}
 
   ~TestApplicationLoader() override {
     if (context_)
       ++context_->num_loader_deletes;
-    test_app_.reset();
+    shell_connection_.reset();
   }
 
   void set_context(TestContext* context) { context_ = context; }
   int num_loads() const { return num_loads_; }
   const GURL& last_requestor_url() const { return last_requestor_url_; }
 
  private:
   // ApplicationLoader implementation.
   void Load(const GURL& url,
-            InterfaceRequest<mojom::Application> application_request) override {
+            InterfaceRequest<mojom::ShellClient> request) override {
     ++num_loads_;
-    test_app_.reset(new ApplicationImpl(this, std::move(application_request)));
+    shell_connection_.reset(new ShellConnection(this, std::move(request)));
   }
 
   // mojo::ShellClient implementation.
   bool AcceptConnection(Connection* connection) override {
     connection->AddService<TestService>(this);
     last_requestor_url_ = GURL(connection->GetRemoteApplicationURL());
     return true;
   }
 
   // InterfaceFactory<TestService> implementation.
   void Create(Connection* connection,
               InterfaceRequest<TestService> request) override {
     new TestServiceImpl(context_, std::move(request));
   }
 
-  scoped_ptr<ApplicationImpl> test_app_;
+  scoped_ptr<ShellConnection> shell_connection_;
   TestContext* context_;
   int num_loads_;
   GURL last_requestor_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
 class ClosingApplicationLoader : public ApplicationLoader {
  private:
   // ApplicationLoader implementation.
   void Load(const GURL& url,
-            InterfaceRequest<mojom::Application> application_request) override {
+            InterfaceRequest<mojom::ShellClient> request) override {
   }
 };
 
 class TesterContext {
  public:
   explicit TesterContext(base::MessageLoop* loop)
       : num_b_calls_(0),
         num_c_calls_(0),
         num_a_deletes_(0),
         num_b_deletes_(0),
@@ skipping 81 matching lines @@
   int num_c_deletes_;
   bool tester_called_quit_;
   bool a_called_quit_;
 
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public TestA {
  public:
-  TestAImpl(ApplicationImpl* app_impl,
+  TestAImpl(ShellConnection* app_impl,
             TesterContext* test_context,
             InterfaceRequest<TestA> request,
             InterfaceFactory<TestC>* factory)
       : test_context_(test_context), binding_(this, std::move(request)) {
     connection_ = app_impl->Connect(kTestBURLString);
     connection_->AddService<TestC>(factory);
     connection_->ConnectToService(&b_);
   }
 
   ~TestAImpl() override {
@@ skipping 79 matching lines @@
                public InterfaceFactory<TestA>,
                public InterfaceFactory<TestB>,
                public InterfaceFactory<TestC> {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
   void Load(const GURL& url,
-            InterfaceRequest<mojom::Application> application_request) override {
-    app_.reset(new ApplicationImpl(this, std::move(application_request)));
+            InterfaceRequest<mojom::ShellClient> request) override {
+    app_.reset(new ShellConnection(this, std::move(request)));
   }
 
   bool AcceptConnection(Connection* connection) override {
     if (!requestor_url_.empty() &&
         requestor_url_ != connection->GetRemoteApplicationURL()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
       base::MessageLoop::current()->QuitWhenIdle();
       return false;
     }
@@ skipping 15 matching lines @@
               InterfaceRequest<TestB> request) override {
     new TestBImpl(connection, context_, std::move(request));
   }
 
   void Create(Connection* connection,
               InterfaceRequest<TestC> request) override {
     new TestCImpl(connection, context_, std::move(request));
   }
 
   TesterContext* context_;
-  scoped_ptr<ApplicationImpl> app_;
+  scoped_ptr<ShellConnection> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
@@ skipping 225 matching lines @@
 
   // A different identity because the domain is different.
   ConnectToService(application_manager_.get(),
                    GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo