De-client shell/application_manager/test.mojom

shell/application_manager/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 "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 "mojo/public/cpp/application/application_connection.h"
@@ skipping 43 matching lines @@
   ~TestServiceImpl() override { --context_->num_impls; }
 
   void OnConnectionError() override {
     if (!base::MessageLoop::current()->is_running())
       return;
     base::MessageLoop::current()->Quit();
     InterfaceImpl::OnConnectionError();
   }
 
   // TestService implementation:
-  void Test(const String& test_string) override {
+  void Test(const String& test_string,
+            const mojo::Callback<void()>& callback) override {
     context_->last_test_string = test_string;
-    client()->AckTest();
+    callback.Run();
   }
 
  private:
   TestContext* context_;
 };
 
-class TestClientImpl : public TestClient {
+class TestClient {
  public:
-  explicit TestClientImpl(TestServicePtr service)
-      : service_(service.Pass()), quit_after_ack_(false) {
-    service_.set_client(this);
-  }
+  explicit TestClient(TestServicePtr service)
+      : service_(service.Pass()), quit_after_ack_(false) {}
 
-  ~TestClientImpl() override { service_.reset(); }
+  ~TestClient() { service_.reset(); }
 
-  void AckTest() override {
+  void AckTest() {
     if (quit_after_ack_)
       base::MessageLoop::current()->Quit();
   }
 
   void Test(const std::string& test_string) {
     quit_after_ack_ = true;
-    service_->Test(test_string);
+    service_->Test(test_string,
+                   base::Bind(&TestClient::AckTest, base::Unretained(this)));
   }
 
  private:
   TestServicePtr service_;
   bool quit_after_ack_;
-  DISALLOW_COPY_AND_ASSIGN(TestClientImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestClient);
 };
 
 class TestApplicationLoader : public ApplicationLoader,
                               public ApplicationDelegate,
                               public InterfaceFactory<TestService> {
  public:
   TestApplicationLoader() : context_(NULL), num_loads_(0) {}
 
   ~TestApplicationLoader() override {
     if (context_)
@@ skipping 308 matching lines @@
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(&test_delegate_));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
     application_manager_->set_default_loader(
         scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
     application_manager_->ConnectToService(GURL(kTestURLString),
                                            &service_proxy);
-    test_client_.reset(new TestClientImpl(service_proxy.Pass()));
+    test_client_.reset(new TestClient(service_proxy.Pass()));
   }
 
   void TearDown() override {
     test_client_.reset(NULL);
     application_manager_.reset(NULL);
   }
 
   void AddLoaderForURL(const GURL& url, const std::string& requestor_url) {
     application_manager_->SetLoaderForURL(
         make_scoped_ptr(new Tester(&tester_context_, requestor_url)), url);
   }
 
   bool HasFactoryForTestURL() {
     ApplicationManager::TestAPI manager_test_api(application_manager_.get());
     return manager_test_api.HasFactoryForURL(GURL(kTestURLString));
   }
 
  protected:
   base::ShadowingAtExitManager at_exit_;
   TestDelegate test_delegate_;
   TestApplicationLoader* test_loader_;
   TesterContext tester_context_;
   TestContext context_;
   base::MessageLoop loop_;
-  scoped_ptr<TestClientImpl> test_client_;
+  scoped_ptr<TestClient> test_client_;
   scoped_ptr<ApplicationManager> application_manager_;
   DISALLOW_COPY_AND_ASSIGN(ApplicationManagerTest);
 };
 
 TEST_F(ApplicationManagerTest, Basic) {
   test_client_->Test("test");
   loop_.Run();
   EXPECT_EQ(std::string("test"), context_.last_test_string);
 }
 
 // Confirm that no arguments are sent to an application by default.
 TEST_F(ApplicationManagerTest, NoArgs) {
   ApplicationManager am(&test_delegate_);
   GURL test_url("test:test");
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url, &test_service);
-  TestClientImpl test_client(test_service.Pass());
+  TestClient test_client(test_service.Pass());
   test_client.Test("test");
   loop_.Run();
   std::vector<std::string> app_args = loader->GetArgs();
   EXPECT_EQ(0U, app_args.size());
 }
 
 // Confirm that arguments are sent to an application.
 TEST_F(ApplicationManagerTest, Args) {
   ApplicationManager am(&test_delegate_);
   GURL test_url("test:test");
   std::vector<std::string> args;
   args.push_back("test_arg1");
   args.push_back("test_arg2");
   am.SetArgsForURL(args, test_url);
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context_);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url, &test_service);
-  TestClientImpl test_client(test_service.Pass());
+  TestClient test_client(test_service.Pass());
   test_client.Test("test");
   loop_.Run();
   std::vector<std::string> app_args = loader->GetArgs();
   ASSERT_EQ(args.size(), app_args.size());
   EXPECT_EQ(args[0], app_args[0]);
   EXPECT_EQ(args[1], app_args[1]);
 }
 
 TEST_F(ApplicationManagerTest, ClientError) {
   test_client_->Test("test");
@@ skipping 164 matching lines @@
   TestServicePtr test_service2;
   application_manager_->ConnectToService(GURL("foo:foo2"), &test_service2);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   TestServicePtr test_service3;
   application_manager_->ConnectToService(GURL("bar:bar"), &test_service2);
   EXPECT_EQ(3, test_loader_->num_loads());
 }
 
 }  // namespace mojo