Adding unit tests for the SafeBrowsingBlockingPage class

chrome/browser/safe_browsing/safe_browsing_blocking_page.cc

 // Copyright (c) 2006-2008 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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 31 matching lines @@
     L"<a href=\"\" onClick=\"sendCommand('showDiagnostic'); return false;\" "
     L"onMouseDown=\"return false;\">%ls</a>";
 
 // The commands returned by the page when the user performs an action.
 static const char* const kShowDiagnosticCommand = "showDiagnostic";
 static const char* const kReportErrorCommand = "reportError";
 static const char* const kLearnMoreCommand = "learnMore";
 static const char* const kProceedCommand = "proceed";
 static const char* const kTakeMeBackCommand = "takeMeBack";
 
+// static
+SafeBrowsingBlockingPageFactory* SafeBrowsingBlockingPage::factory_ = NULL;
+
+// The default SafeBrowsingBlockingPageFactory.  Global, made a singleton so we
+// don't leak it.
+class SafeBrowsingBlockingPageFactoryImpl
+    : public SafeBrowsingBlockingPageFactory {
+ public:
+  SafeBrowsingBlockingPage* CreateSafeBrowsingPage(
+      SafeBrowsingService* service,
+      WebContents* web_contents,
+      const SafeBrowsingBlockingPage::UnsafeResourceList& unsafe_resources) {
+    return new SafeBrowsingBlockingPage(service, web_contents,
+                                        unsafe_resources);
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<SafeBrowsingBlockingPageFactoryImpl>;
+
+  SafeBrowsingBlockingPageFactoryImpl() { }
+
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPageFactoryImpl);
+};
+
 SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
     SafeBrowsingService* sb_service,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
     : InterstitialPage(web_contents,
                        IsMainPage(unsafe_resources),
                        unsafe_resources[0].url),
       sb_service_(sb_service),
       is_main_frame_(IsMainPage(unsafe_resources)),
       unsafe_resources_(unsafe_resources) {
@@ skipping 280 matching lines @@
 
   // Check to see if some new notifications of unsafe resources have been
   // received while we were showing the interstitial.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
   SafeBrowsingBlockingPage* blocking_page = NULL;
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     // Build an interstitial for all the unsafe resources notifications.
     // Don't show it now as showing an interstitial while an interstitial is
     // already showing would cause DontProceed() to be invoked.
-    blocking_page = new SafeBrowsingBlockingPage(sb_service_, tab(),
-                                                 iter->second);
+    blocking_page = factory_->CreateSafeBrowsingPage(sb_service_, tab(),
+                                                     iter->second);
     unsafe_resource_map->erase(iter);
   }
 
   InterstitialPage::Proceed();
   // We are now deleted.
 
   // Now that this interstitial is gone, we can show the new one.
   if (blocking_page)
     blocking_page->Show();
 }
@@ skipping 20 matching lines @@
   }
   InterstitialPage::DontProceed();
   // We are now deleted.
 }
 
 // static
 void SafeBrowsingBlockingPage::NotifySafeBrowsingService(
     SafeBrowsingService* sb_service,
     const UnsafeResourceList& unsafe_resources,
     bool proceed) {
-  base::Thread* io_thread = g_browser_process->io_thread();
-  if (!io_thread)
-    return;
+  MessageLoop* message_loop;
+  if (g_browser_process->io_thread())
+    message_loop = g_browser_process->io_thread()->message_loop();
+  else  // For unit-tests, just post on the current thread.
+    message_loop = MessageLoop::current();
 
-  io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
+  message_loop->PostTask(FROM_HERE, NewRunnableMethod(
       sb_service, &SafeBrowsingService::OnBlockingPageDone, unsafe_resources,
       proceed));
 }
 
 // static
 SafeBrowsingBlockingPage::UnsafeResourceMap*
     SafeBrowsingBlockingPage::GetUnsafeResourcesMap() {
   return Singleton<UnsafeResourceMap>::get();
 }
 
 // static
 void SafeBrowsingBlockingPage::ShowBlockingPage(
     SafeBrowsingService* sb_service,
     const SafeBrowsingService::UnsafeResource& unsafe_resource) {
   WebContents* web_contents = tab_util::GetWebContentsByID(
       unsafe_resource.render_process_host_id, unsafe_resource.render_view_id);
 
   if (!InterstitialPage::GetInterstitialPage(web_contents)) {
     // There are no interstitial currently showing in that tab, go ahead and
     // show this interstitial.
     std::vector<SafeBrowsingService::UnsafeResource> resources;
     resources.push_back(unsafe_resource);
+    // Set up the factory if this has not been done already (tests do that
+    // before this method is called).
+    if (!factory_)
+      factory_ = Singleton<SafeBrowsingBlockingPageFactoryImpl>::get();
     SafeBrowsingBlockingPage* blocking_page =
-        new SafeBrowsingBlockingPage(sb_service, web_contents, resources);
+        factory_->CreateSafeBrowsingPage(sb_service, web_contents, resources);
     blocking_page->Show();
     return;
   }
 
   // Let's queue the interstitial.
   // Note we only expect resources from the page at this point.
   DCHECK(unsafe_resource.resource_type != ResourceType::MAIN_FRAME);
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   (*unsafe_resource_map)[web_contents].push_back(unsafe_resource);
 }
 
 // static
 bool SafeBrowsingBlockingPage::IsMainPage(
     const UnsafeResourceList& unsafe_resources) {
   return unsafe_resources.size() == 1 &&
          unsafe_resources[0].resource_type == ResourceType::MAIN_FRAME;
 }