Allow multiple WebUIControllerFactory objects to be registered. This makes is possible to implement…

content/browser/web_contents/web_contents_impl_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 "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/interstitial_page_impl.h"
 #include "content/browser/web_contents/navigation_entry_impl.h"
 #include "content/browser/web_contents/test_web_contents.h"
+#include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_ui_controller.h"
-#include "content/public/browser/web_ui_controller_factory.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
-#include "googleurl/src/url_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/glue/webkit_glue.h"
 
 namespace content {
 namespace {
 
+const char kTestWebUIUrl[] = "chrome://blah";
+
 class WebContentsImplTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   virtual WebUIController* CreateWebUIControllerForURL(
       WebUI* web_ui, const GURL& url) const OVERRIDE {
-   if (!GetContentClient()->HasWebUIScheme(url))
+   if (!UseWebUI(url))
      return NULL;
 
    return new WebUIController(web_ui);
   }
 
   virtual WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
       const GURL& url) const OVERRIDE {
     return WebUI::kNoWebUI;
   }
 
   virtual bool UseWebUIForURL(BrowserContext* browser_context,
                               const GURL& url) const OVERRIDE {
-    return GetContentClient()->HasWebUIScheme(url);
+    return UseWebUI(url);
   }
 
   virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
                                       const GURL& url) const OVERRIDE {
-    return GetContentClient()->HasWebUIScheme(url);
+    return UseWebUI(url);
   }
 
   virtual bool IsURLAcceptableForWebUI(
       BrowserContext* browser_context,
       const GURL& url,
       bool data_urls_allowed) const {
-    return GetContentClient()->HasWebUIScheme(url);
-  }
-};
-
-class WebContentsImplTestContentClient : public TestContentClient {
- public:
-  WebContentsImplTestContentClient() {
-  }
-
-  virtual bool HasWebUIScheme(const GURL& url) const OVERRIDE {
-    return url.SchemeIs("webcontentsimpltest");
-  }
-};
-
-class WebContentsImplTestBrowserClient : public TestContentBrowserClient {
- public:
-  WebContentsImplTestBrowserClient() {
-  }
-
-  virtual WebUIControllerFactory* GetWebUIControllerFactory() OVERRIDE {
-    return &factory_;
+    return UseWebUI(url);
   }
 
  private:
-  WebContentsImplTestWebUIControllerFactory factory_;
+  bool UseWebUI(const GURL& url) const {
+    return url == GURL(kTestWebUIUrl);
+  }
 };
 
 class TestInterstitialPage;
 
 class TestInterstitialPageDelegate : public InterstitialPageDelegate {
  public:
   TestInterstitialPageDelegate(TestInterstitialPage* interstitial_page)
       : interstitial_page_(interstitial_page) {}
   virtual void CommandReceived(const std::string& command) OVERRIDE;
   virtual std::string GetHTMLContents() OVERRIDE { return std::string(); }
@@ skipping 147 matching lines @@
     interstitial_page_ = NULL;
   }
 
  private:
   TestInterstitialPage* interstitial_page_;
 };
 
 class WebContentsImplTest : public RenderViewHostImplTestHarness {
  public:
   WebContentsImplTest()
-      : old_client_(NULL),
-        old_browser_client_(NULL),
-        ui_thread_(BrowserThread::UI, &message_loop_),
+      : ui_thread_(BrowserThread::UI, &message_loop_),
         file_user_blocking_thread_(
             BrowserThread::FILE_USER_BLOCKING, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_) {
   }
 
   virtual void SetUp() {
-    // These tests treat webcontentsimpltest as a privileged WebUI scheme.
-    // We must register it similarly to kChromeUIScheme.
-    url_util::AddStandardScheme("webcontentsimpltest");
-
-    old_client_ = GetContentClient();
-    old_browser_client_ = GetContentClient()->browser();
-    SetContentClient(&client_);
-    GetContentClient()->set_browser_for_testing(&browser_client_);
     RenderViewHostImplTestHarness::SetUp();
+    WebUIControllerFactory::RegisterFactory(&factory_);
   }
 
   virtual void TearDown() {
-    GetContentClient()->set_browser_for_testing(old_browser_client_);
-    SetContentClient(old_client_);
     RenderViewHostImplTestHarness::TearDown();
+    WebUIControllerFactoryRegistry::UnregisterFactoryForTesting(&factory_);
   }
 
  private:
-  WebContentsImplTestContentClient client_;
-  WebContentsImplTestBrowserClient browser_client_;
-  ContentClient* old_client_;
-  ContentBrowserClient* old_browser_client_;
+  WebContentsImplTestWebUIControllerFactory factory_;
   TestBrowserThread ui_thread_;
   TestBrowserThread file_user_blocking_thread_;
   TestBrowserThread io_thread_;
 };
 
 class TestWebContentsObserver : public WebContentsObserver {
  public:
   TestWebContentsObserver(WebContents* contents)
       : WebContentsObserver(contents) {
   }
@@ skipping 37 matching lines @@
 
   contents()->UpdateTitle(rvh(), 0, ASCIIToUTF16("    Lots O' Whitespace\n"),
                           base::i18n::LEFT_TO_RIGHT);
   EXPECT_EQ(ASCIIToUTF16("Lots O' Whitespace"), contents()->GetTitle());
 }
 
 // Test view source mode for a webui page.
 TEST_F(WebContentsImplTest, NTPViewSource) {
   NavigationControllerImpl& cont =
       static_cast<NavigationControllerImpl&>(controller());
-  const char kUrl[] = "view-source:webcontentsimpltest://blah";
+  const char kUrl[] = "view-source:chrome://blah";
   const GURL kGURL(kUrl);
 
   process()->sink().ClearMessages();
 
   cont.LoadURL(
       kGURL, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   rvh()->GetDelegate()->RenderViewCreated(rvh());
   // Did we get the expected message?
   EXPECT_TRUE(process()->sink().GetFirstMessageMatching(
       ViewMsg_EnableViewSourceMode::ID));
@@ skipping 393 matching lines @@
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, rvh());
   EXPECT_EQ(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 TEST_F(WebContentsImplTest, CrossSiteNavigationBackPreempted) {
   contents()->transition_cross_site = true;
 
   // Start with a web ui page, which gets a new RVH with WebUI bindings.
-  const GURL url1("webcontentsimpltest://blah");
+  const GURL url1("chrome://blah");
   controller().LoadURL(
       url1, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* ntp_rvh = test_rvh();
   contents()->TestDidNavigate(ntp_rvh, 1, url1, PAGE_TRANSITION_TYPED);
   NavigationEntry* entry1 = controller().GetLastCommittedEntry();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(ntp_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(url1, entry1->GetURL());
@@ skipping 116 matching lines @@
 }
 
 // Test that a cross-site navigation is not preempted if the previous
 // renderer sends a FrameNavigate message just before being told to stop.
 // We should only preempt the cross-site navigation if the previous renderer
 // has started a new navigation.  See http://crbug.com/79176.
 TEST_F(WebContentsImplTest, CrossSiteNotPreemptedDuringBeforeUnload) {
   contents()->transition_cross_site = true;
 
   // Navigate to NTP URL.
-  const GURL url("webcontentsimpltest://blah");
+  const GURL url("chrome://blah");
   controller().LoadURL(
       url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* orig_rvh = test_rvh();
   EXPECT_FALSE(contents()->cross_navigation_pending());
 
   // Navigate to new site, with the beforeunload request in flight.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* pending_rvh =
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // Suppose the first navigation tries to commit now, with a
   // ViewMsg_Stop in flight.  This should not cancel the pending navigation,
   // but it should act as if the beforeunload ack arrived.
-  orig_rvh->SendNavigate(1, GURL("webcontentsimpltest://blah"));
+  orig_rvh->SendNavigate(1, GURL("chrome://blah"));
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // The pending navigation should be able to commit successfully.
   contents()->TestDidNavigate(pending_rvh, 1, url2, PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, contents()->GetRenderViewHost());
 }
 
@@ skipping 1079 matching lines @@
   other_contents->NavigateAndCommit(url_normalized);
 
   // Check that an IPC with about:whatever is correctly normalized.
   other_contents->TestDidFailLoadWithError(
       1, url_from_ipc, true, 1, string16());
   EXPECT_EQ(url_normalized, other_observer.last_url());
 }
 
 
 }  // namespace content