Fix chrome --mash

mojo/shell/tests/connect/connect_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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/test/test_suite.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/shell/public/cpp/names.h"
 #include "mojo/shell/public/cpp/shell_test.h"
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "mojo/shell/tests/connect/connect_test.mojom.h"
 
 // Tests that multiple applications can be packaged in a single Mojo application
 // implementing ShellClientFactory; that these applications can be specified by
 // the package's manifest and are thus registered with the PackageManager.
 
 namespace mojo {
 namespace shell {
@@ skipping 104 matching lines @@
   EXPECT_NE(mojom::kInvalidInstanceID, connection->GetRemoteInstanceID());
   EXPECT_EQ(connection->GetRemoteIdentity().name(), kTestAppName);
 }
 
 TEST_F(ConnectTest, Instances) {
   Connector::ConnectParams params_a(
       Identity(kTestAppName, mojom::kInheritUserID, "A"));
   scoped_ptr<Connection> connection_a1 = ConnectTo(&params_a);
   scoped_ptr<Connection> connection_a2 = ConnectTo(&params_a);
   std::string instance_a1, instance_a2;
-  test::mojom::StandaloneAppPtr standalone_app_a1;
+  test::mojom::ConnectTestServicePtr service_a1;
   {
-    connection_a1->GetInterface(&standalone_app_a1);
+    connection_a1->GetInterface(&service_a1);
     base::RunLoop loop;
-    standalone_app_a1->GetInstance(
-        base::Bind(&ReceiveTitle, &instance_a1, &loop));
+    service_a1->GetInstance(base::Bind(&ReceiveTitle, &instance_a1, &loop));
     loop.Run();
   }
-  test::mojom::StandaloneAppPtr standalone_app_a2;
+  test::mojom::ConnectTestServicePtr service_a2;
   {
-    connection_a2->GetInterface(&standalone_app_a2);
+    connection_a2->GetInterface(&service_a2);
     base::RunLoop loop;
-    standalone_app_a2->GetInstance(
-        base::Bind(&ReceiveTitle, &instance_a2, &loop));
+    service_a2->GetInstance(base::Bind(&ReceiveTitle, &instance_a2, &loop));
     loop.Run();
   }
   EXPECT_EQ(instance_a1, instance_a2);
 
   Connector::ConnectParams params_b(
       Identity(kTestAppName, mojom::kInheritUserID, "B"));
   scoped_ptr<Connection> connection_b = ConnectTo(&params_b);
   std::string instance_b;
-  test::mojom::StandaloneAppPtr standalone_app_b;
+  test::mojom::ConnectTestServicePtr service_b;
   {
-    connection_b->GetInterface(&standalone_app_b);
+    connection_b->GetInterface(&service_b);
     base::RunLoop loop;
-    standalone_app_b->GetInstance(
-        base::Bind(&ReceiveTitle, &instance_b, &loop));
+    service_b->GetInstance(base::Bind(&ReceiveTitle, &instance_b, &loop));
     loop.Run();
   }
 
   EXPECT_NE(instance_a1, instance_b);
 }
 
+// When both the unresolved and resolved instance names are their default
+// values, the instance name from the unresolved name must be used.
+// (The case where the instance names differ is covered by
+// LifecycleTest.PackagedApp_CrashCrashesOtherProvidedApp).
+TEST_F(ConnectTest, PreferUnresolvedDefaultInstanceName) {
+  // Connect to an app with no manifest-supplied instance name provided by a
+  // package, the instance name must be derived from the application instance
+  // name, not the package.
+  scoped_ptr<Connection> connection = connector()->Connect(kTestAppName);
+  {
+    base::RunLoop loop;
+    connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
+    loop.Run();
+  }
+
+  std::string instance;
+  {
+    test::mojom::ConnectTestServicePtr service;
+    connection->GetInterface(&service);
+    base::RunLoop loop;
+    service->GetInstance(base::Bind(&ReceiveTitle, &instance, &loop));
+    loop.Run();
+  }
+  EXPECT_EQ(GetNamePath(kTestAppName), instance);
+}
+
 // BlockedInterface should not be exposed to this application because it is not
 // in our CapabilityFilter whitelist.
 TEST_F(ConnectTest, BlockedInterface) {
   scoped_ptr<Connection> connection = connector()->Connect(kTestAppName);
   base::RunLoop run_loop;
   test::mojom::BlockedInterfacePtr blocked;
   connection->GetInterface(&blocked);
   blocked.set_connection_error_handler(base::Bind(&QuitLoop, &run_loop));
   std::string title = "unchanged";
   blocked->GetTitleBlocked(base::Bind(&ReceiveTitle, &title, &run_loop));
@@ skipping 118 matching lines @@
       CompareConnectionState(
           kTestAppAName, test_name(), test_userid(), test_instance_id(),
           kTestAppAName, connection->GetRemoteIdentity().user_id(), remote_id);
     }
 
   }
 }
 
 }  // namespace shell
 }  // namespace mojo