Revert of Simplify mojo_shell since it's now only used for Mandoline.

mojo/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 401 matching lines @@
       replacements.SetScheme("file", url::Component(0, 4));
       mapped_url = mapped_url.ReplaceComponents(replacements);
     }
     return mapped_url;
   }
 
  private:
   std::map<GURL, GURL> mappings_;
 };
 
+class TestExternal : public ApplicationDelegate {
+ public:
+  TestExternal() : configure_incoming_connection_called_(false) {}
+
+  void Initialize(ApplicationImpl* app) override {
+    initialize_args_ = app->args();
+    base::MessageLoop::current()->Quit();
+  }
+
+  bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
+    configure_incoming_connection_called_ = true;
+    base::MessageLoop::current()->Quit();
+    return true;
+  }
+
+  const std::vector<std::string>& initialize_args() const {
+    return initialize_args_;
+  }
+
+  bool configure_incoming_connection_called() const {
+    return configure_incoming_connection_called_;
+  }
+
+ private:
+  std::vector<std::string> initialize_args_;
+  bool configure_incoming_connection_called_;
+};
+
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(&test_delegate_));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
@@ skipping 48 matching lines @@
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
   am.ConnectToService(test_url, &test_service);
   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);
+  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]);
+}
+
+// Confirm that arguments are aggregated through mappings.
+TEST_F(ApplicationManagerTest, ArgsAndMapping) {
+  ApplicationManager am(&test_delegate_);
+  GURL test_url("test:test");
+  GURL test_url2("test:test2");
+  test_delegate_.AddMapping(test_url, test_url2);
+  std::vector<std::string> args;
+  args.push_back("test_arg1");
+  args.push_back("test_arg2");
+  am.SetArgsForURL(args, test_url);
+  std::vector<std::string> args2;
+  args2.push_back("test_arg3");
+  args2.push_back("test_arg4");
+  am.SetArgsForURL(args2, test_url2);
+  TestApplicationLoader* loader = new TestApplicationLoader;
+  loader->set_context(&context_);
+  am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url2);
+  {
+    // Connext to the mapped url
+    TestServicePtr test_service;
+    am.ConnectToService(test_url, &test_service);
+    TestClient test_client(test_service.Pass());
+    test_client.Test("test");
+    loop_.Run();
+    std::vector<std::string> app_args = loader->GetArgs();
+    ASSERT_EQ(args.size() + args2.size(), app_args.size());
+    EXPECT_EQ(args[0], app_args[0]);
+    EXPECT_EQ(args[1], app_args[1]);
+    EXPECT_EQ(args2[0], app_args[2]);
+    EXPECT_EQ(args2[1], app_args[3]);
+  }
+  {
+    // Connext to the target url
+    TestServicePtr test_service;
+    am.ConnectToService(test_url2, &test_service);
+    TestClient test_client(test_service.Pass());
+    test_client.Test("test");
+    loop_.Run();
+    std::vector<std::string> app_args = loader->GetArgs();
+    ASSERT_EQ(args.size() + args2.size(), app_args.size());
+    EXPECT_EQ(args[0], app_args[0]);
+    EXPECT_EQ(args[1], app_args[1]);
+    EXPECT_EQ(args2[0], app_args[2]);
+    EXPECT_EQ(args2[1], app_args[3]);
+  }
+}
+
 TEST_F(ApplicationManagerTest, ClientError) {
   test_client_->Test("test");
   EXPECT_TRUE(HasFactoryForTestURL());
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset();
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
   EXPECT_TRUE(HasFactoryForTestURL());
 }
@@ skipping 169 matching lines @@
   application_manager_->SetLoaderForURL(make_scoped_ptr(custom_loader),
                                         GURL("mojo:foo"));
   test_delegate_.AddMapping(GURL("mojo:foo2"), GURL("mojo:foo"));
 
   TestServicePtr test_service;
   application_manager_->ConnectToService(GURL("mojo:foo2"), &test_service);
   EXPECT_EQ(1, custom_loader->num_loads());
   custom_loader->set_context(nullptr);
 }
 
+TEST_F(ApplicationManagerTest, ExternalApp) {
+  ApplicationPtr application;
+  TestExternal external;
+  std::vector<std::string> args;
+  args.push_back("test");
+  ApplicationImpl app(&external, GetProxy(&application));
+  application_manager_->RegisterExternalApplication(GURL("mojo:test"), args,
+                                                    application.Pass());
+  loop_.Run();
+  EXPECT_EQ(args, external.initialize_args());
+  application_manager_->ConnectToServiceByName(GURL("mojo:test"),
+                                               std::string());
+  loop_.Run();
+  EXPECT_TRUE(external.configure_incoming_connection_called());
+};
+
 TEST_F(ApplicationManagerTest, TestQueryWithLoaders) {
   TestApplicationLoader* url_loader = new TestApplicationLoader;
   TestApplicationLoader* scheme_loader = new TestApplicationLoader;
   application_manager_->SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(url_loader), GURL("test:test1"));
   application_manager_->SetLoaderForScheme(
       scoped_ptr<ApplicationLoader>(scheme_loader), "test");
 
   // test::test1 should go to url_loader.
   TestServicePtr test_service;
@@ skipping 18 matching lines @@
   application_manager_->ConnectToApplication(
       GURL("test:test"), GURL(), nullptr, nullptr,
       base::Bind(&QuitClosure, base::Unretained(&called)));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo