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

mojo/public/cpp/application/tests/service_provider_impl_unittest.cc

 // Copyright 2016 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/public/cpp/application/service_provider_impl.h"
 
 #include <utility>
 
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
@@ skipping 36 matching lines @@
   // |test::PingService|:
   void Ping(const PingCallback& callback) override { callback.Run(); }
 
  private:
   StrongBinding<test::PingService> strong_binding_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(PingServiceImpl);
 };
 
 TEST_F(ServiceProviderImplTest, Basic) {
+  const char kRemoteUrl[] = "https://example.com/remote.mojo";
+  const char kConnectionUrl[] = "https://example.com/me.mojo";
+
   const char kPing1[] = "Ping1";
   const char kPing2[] = "Ping2";
   const char kPing3[] = "Ping3";
 
   ServiceProviderPtr sp;
-  ServiceProviderImpl impl(GetProxy(&sp));
+  ServiceProviderImpl impl(ConnectionContext(ConnectionContext::Type::INCOMING,
+                                             kRemoteUrl, kConnectionUrl),
+                           GetProxy(&sp));
 
   impl.AddServiceNew<test::PingService>(
-      [](const ConnectionContext& connection_context,
-         InterfaceRequest<test::PingService> ping_service_request) {
+      [&kRemoteUrl, &kConnectionUrl](
+          const ConnectionContext& connection_context,
+          InterfaceRequest<test::PingService> ping_service_request) {
+        EXPECT_EQ(ConnectionContext::Type::INCOMING, connection_context.type);
+        EXPECT_EQ(kRemoteUrl, connection_context.remote_url);
+        EXPECT_EQ(kConnectionUrl, connection_context.connection_url);
         new PingServiceImpl(std::move(ping_service_request));
       },
       kPing1);
 
   impl.AddServiceNew<test::PingService>(
-      [](const ConnectionContext& connection_context,
-         InterfaceRequest<test::PingService> ping_service_request) {
+      [&kRemoteUrl, &kConnectionUrl](
+          const ConnectionContext& connection_context,
+          InterfaceRequest<test::PingService> ping_service_request) {
+        EXPECT_EQ(ConnectionContext::Type::INCOMING, connection_context.type);
+        EXPECT_EQ(kRemoteUrl, connection_context.remote_url);
+        EXPECT_EQ(kConnectionUrl, connection_context.connection_url);
         new PingServiceImpl(std::move(ping_service_request));
       },
       kPing2);
 
   {
     test::PingServicePtr ping1;
     ConnectToService(sp.get(), GetProxy(&ping1), kPing1);
     ping1.set_connection_error_handler([this] { QuitLoop(false); });
     ping1->Ping([this] { QuitLoop(true); });
     loop().Run();
@@ skipping 17 matching lines @@
     ping3->Ping([this] { QuitLoop(false); });
     loop().Run();
   }
   loop().RunUntilIdle();  // Run stuff caused by destructors.
 
   sp.reset();
   loop().RunUntilIdle();
 }
 
 TEST_F(ServiceProviderImplTest, CloseAndRebind) {
+  const char kRemoteUrl1[] = "https://example.com/remote1.mojo";
+  const char kRemoteUrl2[] = "https://example.com/remote2.mojo";
+  const char kConnectionUrl[] = "https://example.com/me.mojo";
   const char kPing[] = "Ping";
 
   ServiceProviderPtr sp1;
-  ServiceProviderImpl impl(GetProxy(&sp1));
+  ServiceProviderImpl impl(ConnectionContext(ConnectionContext::Type::INCOMING,
+                                             kRemoteUrl1, kConnectionUrl),
+                           GetProxy(&sp1));
 
   impl.AddServiceNew<test::PingService>(
-      [](const ConnectionContext& connection_context,
-         InterfaceRequest<test::PingService> ping_service_request) {
+      [&kRemoteUrl1, &kRemoteUrl2, &kConnectionUrl](
+          const ConnectionContext& connection_context,
+          InterfaceRequest<test::PingService> ping_service_request) {
+        EXPECT_EQ(ConnectionContext::Type::INCOMING, connection_context.type);
+        EXPECT_TRUE(connection_context.remote_url == kRemoteUrl1 ||
+                    connection_context.remote_url == kRemoteUrl2);
+        EXPECT_EQ(kConnectionUrl, connection_context.connection_url);
         new PingServiceImpl(std::move(ping_service_request));
       },
       kPing);
 
   {
     test::PingServicePtr ping;
     ConnectToService(sp1.get(), GetProxy(&ping), kPing);
     ping.set_connection_error_handler([this] { QuitLoop(false); });
     ping->Ping([this] { QuitLoop(true); });
     loop().Run();
   }
   loop().RunUntilIdle();  // Run stuff caused by destructors.
 
   impl.Close();
   sp1.reset();
   loop().RunUntilIdle();
 
   ServiceProviderPtr sp2;
-  impl.Bind(GetProxy(&sp2));
+  impl.Bind(ConnectionContext(ConnectionContext::Type::INCOMING, kRemoteUrl2,
+                              kConnectionUrl),
+            GetProxy(&sp2));
 
   {
     test::PingServicePtr ping;
     ConnectToService(sp2.get(), GetProxy(&ping), kPing);
     ping.set_connection_error_handler([this] { QuitLoop(false); });
     ping->Ping([this] { QuitLoop(true); });
     loop().Run();
   }
   loop().RunUntilIdle();  // Run stuff caused by destructors.
 
   // Can close multiple times.
   impl.Close();
   impl.Close();
   sp2.reset();
   loop().RunUntilIdle();
 }
 
 TEST_F(ServiceProviderImplTest, Bind) {
+  const char kRemoteUrl[] = "https://example.com/remote.mojo";
+  const char kConnectionUrl[] = "https://example.com/me.mojo";
   const char kPing[] = "Ping";
 
   ServiceProviderPtr sp;
   ServiceProviderImpl impl;
 
-  impl.Bind(GetProxy(&sp));
+  impl.Bind(ConnectionContext(ConnectionContext::Type::INCOMING, kRemoteUrl,
+                              kConnectionUrl),
+            GetProxy(&sp));
 
   impl.AddServiceNew<test::PingService>(
-      [](const ConnectionContext& connection_context,
-         InterfaceRequest<test::PingService> request) {
+      [&kRemoteUrl, &kConnectionUrl](
+          const ConnectionContext& connection_context,
+          InterfaceRequest<test::PingService> request) {
+        EXPECT_EQ(ConnectionContext::Type::INCOMING, connection_context.type);
+        EXPECT_EQ(kRemoteUrl, connection_context.remote_url);
+        EXPECT_EQ(kConnectionUrl, connection_context.connection_url);
         new PingServiceImpl(std::move(request));
       },
       kPing);
 
   {
     test::PingServicePtr ping;
     ConnectToService(sp.get(), GetProxy(&ping), kPing);
     ping.set_connection_error_handler([this] { QuitLoop(false); });
     ping->Ping([this] { QuitLoop(true); });
     loop().Run();
@@ skipping 21 matching lines @@
  private:
   std::function<void(const std::string& service_name)> on_connect_to_service_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(FauxServiceProvider);
 };
 
 TEST_F(ServiceProviderImplTest, FallbackServiceProvider) {
   const char kWhatever[] = "Whatever";
 
   ServiceProviderPtr sp;
-  ServiceProviderImpl impl(GetProxy(&sp));
+  ServiceProviderImpl impl(ConnectionContext(ConnectionContext::Type::INCOMING,
+                                             "https://example.com/remote.mojo",
+                                             "https://example.com/me.mojo"),
+                           GetProxy(&sp));
 
   {
     test::PingServicePtr ping;
     ConnectToService(sp.get(), GetProxy(&ping), kWhatever);
     ping.set_connection_error_handler([this] { QuitLoop(true); });
     ping->Ping([this] { QuitLoop(false); });
     loop().Run();
   }
   loop().RunUntilIdle();  // Run stuff caused by destructors.
 
@@ skipping 30 matching lines @@
   loop().RunUntilIdle();  // Run stuff caused by destructors.
 
   sp.reset();
   loop().RunUntilIdle();
 
   EXPECT_FALSE(was_run);
 }
 
 }  // namespace
 }  // namespace mojo