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

mojo/shell/capability_filter_test.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 "mojo/shell/capability_filter_test.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/common/weak_binding_set.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/package_manager.h"
-#include "mojo/shell/public/cpp/application_impl.h"
 #include "mojo/shell/public/cpp/connection.h"
 #include "mojo/shell/public/cpp/interface_factory.h"
+#include "mojo/shell/public/cpp/shell_connection.h"
 
 namespace mojo {
 namespace shell {
 namespace test {
 
 // Lives on the main thread of the test.
 // Listens for services exposed/blocked and for application connections being
 // closed. Quits |loop| when all expectations are met.
 class ConnectionValidator : public ApplicationLoader,
                             public ShellClient,
@@ skipping 14 matching lines @@
   void PrintUnmetExpectations() {
     for (auto expectation : expectations_)
       ADD_FAILURE() << "Unmet: " << expectation;
     for (auto unexpected : unexpected_)
       ADD_FAILURE() << "Unexpected: " << unexpected;
   }
 
  private:
   // Overridden from ApplicationLoader:
   void Load(const GURL& url,
-            InterfaceRequest<mojom::Application> request) override {
-    app_.reset(new ApplicationImpl(this, std::move(request)));
+            InterfaceRequest<mojom::ShellClient> request) override {
+    app_.reset(new ShellConnection(this, std::move(request)));
   }
 
   // Overridden from ShellClient:
   bool AcceptConnection(Connection* connection) override {
     connection->AddService<Validator>(this);
     return true;
   }
 
   // Overridden from InterfaceFactory<Validator>:
   void Create(Connection* connection,
@@ skipping 22 matching lines @@
       if (expectations_.empty())
         loop_->QuitWhenIdle();
     } else {
       // This is a test failure, and will result in PrintUnexpectedExpecations()
       // being called.
       unexpected_.insert(result);
       loop_->QuitWhenIdle();
     }
   }
 
-  scoped_ptr<ApplicationImpl> app_;
+  scoped_ptr<ShellConnection> app_;
   std::set<std::string> expectations_;
   std::set<std::string> unexpected_;
   base::MessageLoop* loop_;
   WeakBindingSet<Validator> validator_bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionValidator);
 };
 
 // This class models a system service that exposes two interfaces, Safe and
 // Unsafe. The interface Unsafe is not to be exposed to untrusted applications.
@@ skipping 79 matching lines @@
   validator_->ConnectionClosed(url_, service_url);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TestLoader:
 
 TestLoader::TestLoader(ShellClient* delegate) : delegate_(delegate) {}
 TestLoader::~TestLoader() {}
 
 void TestLoader::Load(const GURL& url,
-                      InterfaceRequest<mojom::Application> request) {
-  app_.reset(new ApplicationImpl(delegate_.get(), std::move(request)));
+                      InterfaceRequest<mojom::ShellClient> request) {
+  app_.reset(new ShellConnection(delegate_.get(), std::move(request)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CapabilityFilterTest:
 
 CapabilityFilterTest::CapabilityFilterTest() : validator_(nullptr) {}
 CapabilityFilterTest::~CapabilityFilterTest() {}
 
 void CapabilityFilterTest::RunBlockingTest() {
   std::set<std::string> expectations;
@@ skipping 135 matching lines @@
 void CapabilityFilterTest::RunTest() {
   loop()->Run();
   EXPECT_TRUE(validator_->expectations_met());
   if (!validator_->expectations_met())
     validator_->PrintUnmetExpectations();
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo