Remove ApplicationManagerTest.BCallC.

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 "shell/application_manager/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 "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/application/interface_factory.h"
-#include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/application_manager/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using mojo::Application;
 using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::ApplicationImpl;
@@ skipping 228 matching lines @@
     test_context_->IncrementNumADeletes();
     if (base::MessageLoop::current()->is_running())
       Quit();
   }
 
  private:
   void CallB() override {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
-  void CallCFromB() override {
-    b_->CallC(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
-  }
-
   void Quit() {
     base::MessageLoop::current()->Quit();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
   TesterContext* test_context_;
   TestBPtr b_;
   StrongBinding<TestA> binding_;
 };
 
 class TestBImpl : public TestB {
  public:
   TestBImpl(ApplicationConnection* connection,
             TesterContext* test_context,
             InterfaceRequest<TestB> request)
-      : test_context_(test_context), binding_(this, request.Pass()) {
-    connection->ConnectToService(&c_);
-  }
+      : test_context_(test_context), binding_(this, request.Pass()) {}
 
   ~TestBImpl() override {
     test_context_->IncrementNumBDeletes();
     if (base::MessageLoop::current()->is_running())
       base::MessageLoop::current()->Quit();
     test_context_->QuitSoon();
   }
 
  private:
   void B(const Callback<void()>& callback) override {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
-  void CallC(const Callback<void()>& callback) override {
-    test_context_->IncrementNumBCalls();
-    c_->C(callback);
-  }
-
-  TesterContext* test_context_;
-  TestCPtr c_;
-  StrongBinding<TestB> binding_;
-};
-
-class TestCImpl : public TestC {
- public:
-  TestCImpl(ApplicationConnection* connection,
-            TesterContext* test_context,
-            InterfaceRequest<TestC> request)
-      : test_context_(test_context), binding_(this, request.Pass()) {}
-
-  ~TestCImpl() override { test_context_->IncrementNumCDeletes(); }
-
- private:
-  void C(const Callback<void()>& callback) override {
-    test_context_->IncrementNumCCalls();
-    callback.Run();
-  }
-
   TesterContext* test_context_;
-  StrongBinding<TestC> binding_;
+  StrongBinding<TestB> binding_;
 };
 
 class Tester : public ApplicationDelegate,
                public ApplicationLoader,
                public InterfaceFactory<TestA>,
-               public InterfaceFactory<TestB>,
-               public InterfaceFactory<TestC> {
+               public InterfaceFactory<TestB> {
  public:
   Tester(TesterContext* context, const std::string& requestor_url)
       : context_(context), requestor_url_(requestor_url) {}
   ~Tester() override {}
 
  private:
   void Load(const GURL& url,
             InterfaceRequest<Application> application_request) override {
     app_.reset(new ApplicationImpl(this, application_request.Pass()));
   }
@@ skipping 10 matching lines @@
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestA> request) override {
     mojo::InterfaceHandle<mojo::ServiceProvider> incoming_sp_handle;
-    mojo::InterfaceHandle<mojo::ServiceProvider> outgoing_sp_handle;
-    mojo::InterfaceRequest<mojo::ServiceProvider> outgoing_sp_request =
-        GetProxy(&outgoing_sp_handle);
     app_->shell()->ConnectToApplication(kTestBURLString,
-                                        GetProxy(&incoming_sp_handle),
-                                        outgoing_sp_handle.Pass());
-    std::unique_ptr<mojo::ServiceProviderImpl> outgoing_sp_impl(
-        new mojo::ServiceProviderImpl(outgoing_sp_request.Pass()));
-    outgoing_sp_impl->AddService<TestC>(this);
-    outgoing_sp_impls_for_b_.push_back(std::move(outgoing_sp_impl));
+                                        GetProxy(&incoming_sp_handle), nullptr);
     a_bindings_.push_back(
         new TestAImpl(incoming_sp_handle.Pass(), context_, request.Pass()));
   }
 
   void Create(ApplicationConnection* connection,
               InterfaceRequest<TestB> request) override {
     new TestBImpl(connection, context_, request.Pass());
   }
 
-  void Create(ApplicationConnection* connection,
-              InterfaceRequest<TestC> request) override {
-    new TestCImpl(connection, context_, request.Pass());
-  }
-
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
-  std::vector<std::unique_ptr<mojo::ServiceProviderImpl>>
-      outgoing_sp_impls_for_b_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class TestDelegate : public ApplicationManager::Delegate {
  public:
   void AddMapping(const GURL& from, const GURL& to) { mappings_[from] = to; }
 
   // ApplicationManager::Delegate
   GURL ResolveMappings(const GURL& url) override {
     auto it = mappings_.find(url);
@@ skipping 308 matching lines @@
   AddLoaderForURL(GURL(kTestBURLString), kTestAURLString);
 
   TestAPtr a;
   application_manager_->ConnectToService(GURL(kTestAURLString), &a);
   a->CallB();
   loop_.Run();
   EXPECT_EQ(1, tester_context_.num_b_calls());
   EXPECT_TRUE(tester_context_.a_called_quit());
 }
 
-// A calls B which calls C.
-TEST_F(ApplicationManagerTest, BCallC) {
-  // Any url can load a.
-  AddLoaderForURL(GURL(kTestAURLString), std::string());
-
-  // Only a can load b.
-  AddLoaderForURL(GURL(kTestBURLString), kTestAURLString);
-
-  TestAPtr a;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
-  a->CallCFromB();
-  loop_.Run();
-
-  EXPECT_EQ(1, tester_context_.num_b_calls());
-  EXPECT_EQ(1, tester_context_.num_c_calls());
-  EXPECT_TRUE(tester_context_.a_called_quit());
-}
-
 // Confirm that a service impl will be deleted if the app that connected to
 // it goes away.
 TEST_F(ApplicationManagerTest, BDeleted) {
   AddLoaderForURL(GURL(kTestAURLString), std::string());
   AddLoaderForURL(GURL(kTestBURLString), std::string());
 
   TestAPtr a;
   application_manager_->ConnectToService(GURL(kTestAURLString), &a);
 
   a->CallB();
@@ skipping 102 matching lines @@
   bool called = false;
   application_manager_->ConnectToApplication(
       GURL("test:test"), GURL(), nullptr, nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 }  // namespace
 }  // namespace shell