Ignore title parameter for navigator.registerProtocolHandler.

chrome/browser/custom_handlers/protocol_handler_registry_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <set>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 302 matching lines @@
     test_protocol_handler_(CreateProtocolHandler("test", "test")) {}
 
   FakeDelegate* delegate() const { return delegate_; }
   ProtocolHandlerRegistry* registry() { return registry_.get(); }
   TestingProfile* profile() const { return profile_.get(); }
   const ProtocolHandler& test_protocol_handler() const {
     return test_protocol_handler_;
   }
 
   ProtocolHandler CreateProtocolHandler(const std::string& protocol,
-                                        const GURL& url,
-                                        const std::string& title) {
-    return ProtocolHandler::CreateProtocolHandler(protocol, url,
-        base::UTF8ToUTF16(title));
+                                        const GURL& url) {
+    return ProtocolHandler::CreateProtocolHandler(protocol, url);
   }
 
   ProtocolHandler CreateProtocolHandler(const std::string& protocol,
-      const std::string& name) {
-    return CreateProtocolHandler(protocol, GURL("http://" + name + "/%s"),
-        name);
+                                        const std::string& name) {
+    return CreateProtocolHandler(protocol, GURL("http://" + name + "/%s"));
   }
 
   void RecreateRegistry(bool initialize) {
     TeadDownRegistry();
     SetUpRegistry(initialize);
   }
 
   // Returns a new registry, initializing it if |initialize| is true.
   // Caller assumes ownership for the object
   void SetUpRegistry(bool initialize) {
     delegate_ = new FakeDelegate();
     registry_.reset(new ProtocolHandlerRegistry(profile(), delegate()));
     if (initialize) registry_->InitProtocolSettings();
   }
 
   void TeadDownRegistry() {
     registry_->Shutdown();
     registry_.reset();
     // Registry owns the delegate_ it handles deletion of that object.
   }
 
   virtual void SetUp() {
     profile_.reset(new TestingProfile());
     CHECK(profile_->GetPrefs());
     SetUpRegistry(true);
     test_protocol_handler_ =
-        CreateProtocolHandler("test", GURL("http://test.com/%s"), "Test");
+        CreateProtocolHandler("test", GURL("http://test.com/%s"));
   }
 
   virtual void TearDown() {
     TeadDownRegistry();
   }
 
   TestMessageLoop loop_;
 
  private:
   content::TestBrowserThread ui_thread_;
@@ skipping 71 matching lines @@
 
 TEST_F(ProtocolHandlerRegistryTest, IgnoreProtocolHandler) {
   registry()->OnIgnoreRegisterProtocolHandler(test_protocol_handler());
   ASSERT_TRUE(registry()->IsIgnored(test_protocol_handler()));
 
   registry()->RemoveIgnoredHandler(test_protocol_handler());
   ASSERT_FALSE(registry()->IsIgnored(test_protocol_handler()));
 }
 
 TEST_F(ProtocolHandlerRegistryTest, IgnoreEquivalentProtocolHandler) {
-  ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s"),
-                                              "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s"),
-                                              "test2");
+  ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s"));
+  ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s"));
 
   registry()->OnIgnoreRegisterProtocolHandler(ph1);
   ASSERT_TRUE(registry()->IsIgnored(ph1));
   ASSERT_TRUE(registry()->HasIgnoredEquivalent(ph2));
 
   registry()->RemoveIgnoredHandler(ph1);
   ASSERT_FALSE(registry()->IsIgnored(ph1));
   ASSERT_FALSE(registry()->HasIgnoredEquivalent(ph2));
 }
 
@@ skipping 116 matching lines @@
 TEST_F(ProtocolHandlerRegistryTest, TestIsRegistered) {
   ProtocolHandler ph1 = CreateProtocolHandler("test", "test1");
   ProtocolHandler ph2 = CreateProtocolHandler("test", "test2");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   registry()->OnAcceptRegisterProtocolHandler(ph2);
 
   ASSERT_TRUE(registry()->IsRegistered(ph1));
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestIsEquivalentRegistered) {
-  ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s"),
-                                              "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s"),
-                                              "test2");
+  ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s"));
+  ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s"));
   registry()->OnAcceptRegisterProtocolHandler(ph1);
 
   ASSERT_TRUE(registry()->IsRegistered(ph1));
   ASSERT_TRUE(registry()->HasRegisteredEquivalent(ph2));
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestSilentlyRegisterHandler) {
-  ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/%s"),
-                                              "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/%s"),
-                                              "test2");
-  ProtocolHandler ph3 = CreateProtocolHandler("ignore", GURL("http://test/%s"),
-                                              "ignore1");
-  ProtocolHandler ph4 = CreateProtocolHandler("ignore", GURL("http://test/%s"),
-                                              "ignore2");
+  ProtocolHandler ph1 = CreateProtocolHandler("test", GURL("http://test/1/%s"));
+  ProtocolHandler ph2 = CreateProtocolHandler("test", GURL("http://test/2/%s"));
+  ProtocolHandler ph3 = CreateProtocolHandler("ignore", GURL("http://test/%s"));
+  ProtocolHandler ph4 = CreateProtocolHandler("ignore", GURL("http://test/%s"));
 
   ASSERT_FALSE(registry()->SilentlyHandleRegisterHandlerRequest(ph1));
   ASSERT_FALSE(registry()->IsRegistered(ph1));
 
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   ASSERT_TRUE(registry()->IsRegistered(ph1));
 
   ASSERT_TRUE(registry()->SilentlyHandleRegisterHandlerRequest(ph2));
   ASSERT_FALSE(registry()->IsRegistered(ph1));
   ASSERT_TRUE(registry()->IsRegistered(ph2));
@@ skipping 232 matching lines @@
   registry()->OnAcceptRegisterProtocolHandler(ph1);
 
   scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor(
       registry()->CreateJobInterceptorFactory());
   AssertWillHandle(mailto, true, interceptor.get());
   registry()->Disable();
   AssertWillHandle(mailto, false, interceptor.get());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestReplaceHandler) {
-  ProtocolHandler ph1 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/%s"), "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/updated-url/%s"), "test2");
+  ProtocolHandler ph1 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/%s"));
+  ProtocolHandler ph2 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s"));
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   ASSERT_TRUE(registry()->AttemptReplace(ph2));
   const ProtocolHandler& handler(registry()->GetHandlerFor("mailto"));
   ASSERT_EQ(handler.url(), ph2.url());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestReplaceNonDefaultHandler) {
-  ProtocolHandler ph1 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/%s"), "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/updated-url/%s"), "test2");
-  ProtocolHandler ph3 = CreateProtocolHandler("mailto",
-      GURL("http://else.com/%s"), "test3");
+  ProtocolHandler ph1 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/%s"));
+  ProtocolHandler ph2 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s"));
+  ProtocolHandler ph3 =
+      CreateProtocolHandler("mailto", GURL("http://else.com/%s"));
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   registry()->OnAcceptRegisterProtocolHandler(ph3);
   ASSERT_TRUE(registry()->AttemptReplace(ph2));
   const ProtocolHandler& handler(registry()->GetHandlerFor("mailto"));
   ASSERT_EQ(handler.url(), ph3.url());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestReplaceRemovesStaleHandlers) {
-  ProtocolHandler ph1 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/%s"), "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/updated-url/%s"), "test2");
-  ProtocolHandler ph3 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/third/%s"), "test");
+  ProtocolHandler ph1 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/%s"));
+  ProtocolHandler ph2 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s"));
+  ProtocolHandler ph3 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/third/%s"));
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   registry()->OnAcceptRegisterProtocolHandler(ph2);
 
   // This should replace the previous two handlers.
   ASSERT_TRUE(registry()->AttemptReplace(ph3));
   const ProtocolHandler& handler(registry()->GetHandlerFor("mailto"));
   ASSERT_EQ(handler.url(), ph3.url());
   registry()->RemoveHandler(ph3);
   ASSERT_TRUE(registry()->GetHandlerFor("mailto").IsEmpty());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestIsSameOrigin) {
-  ProtocolHandler ph1 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/%s"), "test1");
-  ProtocolHandler ph2 = CreateProtocolHandler("mailto",
-      GURL("http://test.com/updated-url/%s"), "test2");
-  ProtocolHandler ph3 = CreateProtocolHandler("mailto",
-      GURL("http://other.com/%s"), "test");
+  ProtocolHandler ph1 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/%s"));
+  ProtocolHandler ph2 =
+      CreateProtocolHandler("mailto", GURL("http://test.com/updated-url/%s"));
+  ProtocolHandler ph3 =
+      CreateProtocolHandler("mailto", GURL("http://other.com/%s"));
   ASSERT_EQ(ph1.url().GetOrigin() == ph2.url().GetOrigin(),
       ph1.IsSameOrigin(ph2));
   ASSERT_EQ(ph1.url().GetOrigin() == ph2.url().GetOrigin(),
       ph2.IsSameOrigin(ph1));
   ASSERT_EQ(ph2.url().GetOrigin() == ph3.url().GetOrigin(),
       ph2.IsSameOrigin(ph3));
   ASSERT_EQ(ph3.url().GetOrigin() == ph2.url().GetOrigin(),
       ph3.IsSameOrigin(ph2));
 }
 
 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestInstallDefaultHandler) {
   RecreateRegistry(false);
-  registry()->AddPredefinedHandler(CreateProtocolHandler(
-      "test", GURL("http://test.com/%s"), "Test"));
+  registry()->AddPredefinedHandler(
+      CreateProtocolHandler("test", GURL("http://test.com/%s")));
   registry()->InitProtocolSettings();
   std::vector<std::string> protocols;
   registry()->GetRegisteredProtocols(&protocols);
   ASSERT_EQ(static_cast<size_t>(1), protocols.size());
 }