Cache ShellImpl by resolved URL, not initial URL

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/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
@@ skipping 384 matching lines @@
   }
 
   int call_count() const { return call_count_; }
 
  private:
   int call_count_;
   GURL url_;
   DISALLOW_COPY_AND_ASSIGN(TestServiceInterceptor);
 };
 
+class TestDelegate : public ApplicationManager::Delegate {
+ public:
+  void AddMapping(const GURL& from, const GURL& to) {
+    mappings_[from] = to;
+  }
+
+  // ApplicationManager::Delegate
+  virtual GURL ResolveURL(const GURL& url) override {
+    auto it = mappings_.find(url);
+    if (it != mappings_.end())
+      return it->second;
+    return url;
+  }
+
+  virtual void OnApplicationError(const GURL& url) override {
+  }
+
+ private:
+  std::map<GURL, GURL> mappings_;
+};
+
 }  // namespace
 
 class ApplicationManagerTest : public testing::Test {
  public:
   ApplicationManagerTest() : tester_context_(&loop_) {}
 
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
-    application_manager_.reset(new ApplicationManager);
-    TestApplicationLoader* default_loader = new TestApplicationLoader;
-    default_loader->set_context(&context_);
+    application_manager_.reset(new ApplicationManager(&test_delegate_));
+    test_loader_ = new TestApplicationLoader;
+    test_loader_->set_context(&context_);
     application_manager_->set_default_loader(
-        scoped_ptr<ApplicationLoader>(default_loader));
+        scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
     application_manager_->ConnectToService(GURL(kTestURLString),
                                            &service_proxy);
     test_client_.reset(new TestClientImpl(service_proxy.Pass()));
   }
 
   void TearDown() override {
     test_client_.reset(NULL);
     application_manager_.reset(NULL);
@@ skipping 14 matching lines @@
     application_manager_->SetLoaderForURL(MakeLoader(requestor_url), url);
   }
 
   bool HasFactoryForTestURL() {
     ApplicationManager::TestAPI manager_test_api(application_manager_.get());
     return manager_test_api.HasFactoryForURL(GURL(kTestURLString));
   }
 
  protected:
   base::ShadowingAtExitManager at_exit_;
+  TestDelegate test_delegate_;
+  TestApplicationLoader* test_loader_;
   TesterContext tester_context_;
   TestContext context_;
   base::MessageLoop loop_;
   scoped_ptr<TestClientImpl> test_client_;
   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 no arguments are sent to an application by default.
 TEST_F(ApplicationManagerTest, NoArgs) {
-  ApplicationManager am;
+  ApplicationManager am(&test_delegate_);
   GURL test_url("test:test");
   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(0U, app_args.size());
 }
 
 // Confirm that arguments are sent to an application.
 TEST_F(ApplicationManagerTest, Args) {
-  ApplicationManager am;
+  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);
   TestContext context;
   TestApplicationLoader* loader = new TestApplicationLoader;
   loader->set_context(&context);
   am.SetLoaderForURL(scoped_ptr<ApplicationLoader>(loader), test_url);
   TestServicePtr test_service;
@@ skipping 13 matching lines @@
   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 am;
+    ApplicationManager am(&test_delegate_);
     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_);
@@ skipping 139 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());
 }
 
+TEST_F(ApplicationManagerTest, MappedURLsShouldNotCauseDuplicateLoad) {
+  test_delegate_.AddMapping(GURL("foo:foo2"), GURL("foo:foo"));
+  // 1 because ApplicationManagerTest connects once at startup.
+  EXPECT_EQ(1, test_loader_->num_loads());
+
+  TestServicePtr test_service;
+  application_manager_->ConnectToService(GURL("foo:foo"), &test_service);
+  EXPECT_EQ(2, test_loader_->num_loads());
+
+  TestServicePtr test_service2;
+  application_manager_->ConnectToService(GURL("foo:foo2"), &test_service2);
+  EXPECT_EQ(2, test_loader_->num_loads());
+
+  TestServicePtr test_service3;
+  application_manager_->ConnectToService(GURL("bar:bar"), &test_service2);
+  EXPECT_EQ(3, test_loader_->num_loads());
+}
+
 }  // namespace mojo