Add Initialize() method to Application with ability to send args using

mojo/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/message_loop/message_loop.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
 #include "mojo/application_manager/background_shell_application_loader.h"
@@ skipping 89 matching lines @@
   TestApplicationLoader() : context_(NULL), num_loads_(0) {}
 
   virtual ~TestApplicationLoader() {
     if (context_)
       ++context_->num_loader_deletes;
     test_app_.reset(NULL);
   }
 
   void set_context(TestContext* context) { context_ = context; }
   int num_loads() const { return num_loads_; }
+  std::vector<std::string> GetArgs() {
+    return test_app_->args().To<std::vector<std::string> >();
+  }
 
  private:
   // ApplicationLoader implementation.
   virtual void Load(ApplicationManager* manager,
                     const GURL& url,
                     scoped_refptr<LoadCallbacks> callbacks) OVERRIDE {
     ++num_loads_;
     test_app_.reset(
         new ApplicationImpl(this, callbacks->RegisterApplication().Pass()));
   }
@@ skipping 339 matching lines @@
   scoped_ptr<ApplicationManager> application_manager_;
   DISALLOW_COPY_AND_ASSIGN(ApplicationManagerTest);
 };
 
 TEST_F(ApplicationManagerTest, Basic) {
   test_client_->Test("test");
   loop_.Run();
   EXPECT_EQ(std::string("test"), context_.last_test_string);
 }
 
+// Confirm that arguments are sent to an application.
+TEST_F(ApplicationManagerTest, Args) {
+  ApplicationManager am;
+  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);
+  TestContext context;
+  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);
+  TestClientImpl test_client(test_service.Pass());
+  test_client.Test("test");
+  loop_.Run();
+  std::vector<std::string> app_args = loader->GetArgs();
+  EXPECT_EQ(args.size(), app_args.size());
+}
+
 TEST_F(ApplicationManagerTest, ClientError) {
   test_client_->Test("test");
   EXPECT_TRUE(HasFactoryForTestURL());
   loop_.Run();
   EXPECT_EQ(1, context_.num_impls);
   test_client_.reset(NULL);
   loop_.Run();
   EXPECT_EQ(0, context_.num_impls);
   EXPECT_TRUE(HasFactoryForTestURL());
 }
 
 TEST_F(ApplicationManagerTest, Deletes) {
   {
-    ApplicationManager sm;
+    ApplicationManager am;
     TestApplicationLoader* default_loader = new TestApplicationLoader;
     default_loader->set_context(&context_);
     TestApplicationLoader* url_loader1 = new TestApplicationLoader;
     TestApplicationLoader* url_loader2 = new TestApplicationLoader;
     url_loader1->set_context(&context_);
     url_loader2->set_context(&context_);
     TestApplicationLoader* scheme_loader1 = new TestApplicationLoader;
     TestApplicationLoader* scheme_loader2 = new TestApplicationLoader;
     scheme_loader1->set_context(&context_);
     scheme_loader2->set_context(&context_);
-    sm.set_default_loader(scoped_ptr<ApplicationLoader>(default_loader));
-    sm.SetLoaderForURL(scoped_ptr<ApplicationLoader>(url_loader1),
+    am.set_default_loader(scoped_ptr<ApplicationLoader>(default_loader));
+    am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(url_loader1),
                        GURL("test:test1"));
-    sm.SetLoaderForURL(scoped_ptr<ApplicationLoader>(url_loader2),
+    am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(url_loader2),
                        GURL("test:test1"));
-    sm.SetLoaderForScheme(scoped_ptr<ApplicationLoader>(scheme_loader1),
+    am.SetLoaderForScheme(scoped_ptr<ApplicationLoader>(scheme_loader1),
                           "test");
-    sm.SetLoaderForScheme(scoped_ptr<ApplicationLoader>(scheme_loader2),
+    am.SetLoaderForScheme(scoped_ptr<ApplicationLoader>(scheme_loader2),
                           "test");
   }
   EXPECT_EQ(5, context_.num_loader_deletes);
 }
 
 // Confirm that both urls and schemes can have their loaders explicitly set.
 TEST_F(ApplicationManagerTest, SetLoaders) {
-  ApplicationManager sm;
   TestApplicationLoader* default_loader = new TestApplicationLoader;
   TestApplicationLoader* url_loader = new TestApplicationLoader;
   TestApplicationLoader* scheme_loader = new TestApplicationLoader;
   application_manager_->set_default_loader(
       scoped_ptr<ApplicationLoader>(default_loader));
   application_manager_->SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(url_loader), GURL("test:test1"));
   application_manager_->SetLoaderForScheme(
       scoped_ptr<ApplicationLoader>(scheme_loader), "test");
 
@@ skipping 115 matching lines @@
   std::string url("test:test3");
   TestServicePtr test_service;
   application_manager_->ConnectToService(GURL(url), &test_service);
 
   EXPECT_EQ(1, interceptor.call_count());
   EXPECT_EQ(url, interceptor.url_spec());
   EXPECT_EQ(1, default_loader->num_loads());
 }
 
 }  // namespace mojo