Change InterfaceFactory<I>::Create() to take a ConnectionContext instead of an ApplicationConnectio…

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/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;
 using mojo::Callback;
+using mojo::ConnectionContext;
 using mojo::InterfaceFactory;
 using mojo::InterfaceRequest;
 using mojo::StrongBinding;
 
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
@@ skipping 82 matching lines @@
     test_app_.reset(new ApplicationImpl(this, application_request.Pass()));
   }
 
   // ApplicationDelegate implementation.
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     connection->AddService(this);
     return true;
   }
 
   // InterfaceFactory implementation.
-  void Create(ApplicationConnection* connection,
+  void Create(const ConnectionContext& connection_context,
               InterfaceRequest<TestService> request) override {
     new TestServiceImpl(context_, request.Pass());
   }
 
   scoped_ptr<ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
@@ skipping 127 matching lines @@
     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)
+  TestBImpl(TesterContext* test_context, InterfaceRequest<TestB> request)
       : 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:
@@ skipping 30 matching lines @@
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
-  void Create(ApplicationConnection* connection,
+  void Create(const ConnectionContext& connection_context,
               InterfaceRequest<TestA> request) override {
     mojo::InterfaceHandle<mojo::ServiceProvider> incoming_sp_handle;
     app_->shell()->ConnectToApplication(kTestBURLString,
                                         GetProxy(&incoming_sp_handle), nullptr);
     a_bindings_.push_back(
         new TestAImpl(incoming_sp_handle.Pass(), context_, request.Pass()));
   }
 
-  void Create(ApplicationConnection* connection,
+  void Create(const ConnectionContext& connection_context,
               InterfaceRequest<TestB> request) override {
-    new TestBImpl(connection, context_, request.Pass());
+    new TestBImpl(context_, request.Pass());
   }
 
   TesterContext* context_;
   scoped_ptr<ApplicationImpl> app_;
   std::string requestor_url_;
   ScopedVector<TestAImpl> a_bindings_;
 };
 
 class TestDelegate : public ApplicationManager::Delegate {
  public:
@@ skipping 435 matching lines @@
   bool called = false;
   application_manager_->ConnectToApplication(
       GURL("test:test"), GURL(), nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 }  // namespace
 }  // namespace shell