Add TestBrowserThreadBundle into RenderViewHostTestHarness. Kill some unnecessary real threads.

chrome/browser/safe_browsing/malware_details_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 <algorithm>
 
 #include "base/bind.h"
 #include "base/pickle.h"
+#include "base/run_loop.h"
 #include "base/time.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/malware_details_history.h"
 #include "chrome/browser/safe_browsing/report.pb.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/safe_browsing/safebrowsing_messages.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/test/test_browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 79 matching lines @@
   int rv =
       context_getter->GetURLRequestContext()->http_transaction_factory()->
       GetCache()->GetBackend(&cache, cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 
   std::string empty;
   WriteToEntry(cache, kMalwareURL, kMalwareHeaders, kMalwareData);
   WriteToEntry(cache, kLandingURL, kLandingHeaders, kLandingData);
 }
 
-void QuitUIMessageLoop() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          MessageLoop::QuitClosure());
-}
-
 // Lets us provide a MockURLRequestContext with an HTTP Cache we pre-populate.
 // Also exposes the constructor.
 class MalwareDetailsWrap : public MalwareDetails {
  public:
   MalwareDetailsWrap(
       SafeBrowsingUIManager* ui_manager,
       WebContents* web_contents,
       const SafeBrowsingUIManager::UnsafeResource& unsafe_resource,
       net::URLRequestContextGetter* request_context_getter)
       : MalwareDetails(ui_manager, web_contents, unsafe_resource) {
 
     request_context_getter_ = request_context_getter;
   }
 
  private:
   virtual ~MalwareDetailsWrap() {}
 };
 
 class MockSafeBrowsingUIManager : public SafeBrowsingUIManager {
  public:
+  base::RunLoop* run_loop_;
   // The safe browsing UI manager does not need a service for this test.
   MockSafeBrowsingUIManager()
-      : SafeBrowsingUIManager(NULL) {}
+      : SafeBrowsingUIManager(NULL), run_loop_(NULL) {}
 
   // When the MalwareDetails is done, this is called.
   virtual void SendSerializedMalwareDetails(
       const std::string& serialized) OVERRIDE {
     DVLOG(1) << "SendSerializedMalwareDetails";
-    // Notify WaitForSerializedReport.
-    BrowserThread::PostTask(BrowserThread::IO,
-                            FROM_HERE,
-                            base::Bind(&QuitUIMessageLoop));
+    run_loop_->Quit();
+    run_loop_ = NULL;
     serialized_ = serialized;
   }
 
+  // Used to synchronize SendSerializedMalwareDetails() with
+  // WaitForSerializedReport(). RunLoop::RunUntilIdle() is not sufficient
+  // because the MessageLoop task queue completely drains at some point
+  // between the send and the wait.
+  void SetRunLoopToQuit(base::RunLoop* run_loop) {
+    DCHECK(run_loop_ == NULL);
+    run_loop_ = run_loop;
+  }
+
   const std::string& GetSerialized() {
     return serialized_;
   }
 
  private:
   virtual ~MockSafeBrowsingUIManager() {}
 
   std::string serialized_;
   DISALLOW_COPY_AND_ASSIGN(MockSafeBrowsingUIManager);
 };
 
 }  // namespace.
 
 class MalwareDetailsTest : public ChromeRenderViewHostTestHarness {
  public:
   typedef SafeBrowsingUIManager::UnsafeResource UnsafeResource;
 
   MalwareDetailsTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        io_thread_(BrowserThread::IO),
-        ui_manager_(new MockSafeBrowsingUIManager()) {
+      : ui_manager_(new MockSafeBrowsingUIManager()) {
   }
 
-  virtual void SetUp() {
+  virtual void SetUp() OVERRIDE {
     ChromeRenderViewHostTestHarness::SetUp();
-    // The URLFetcher checks that the messageloop type is IO.
-    ASSERT_TRUE(io_thread_.StartIOThread());
-
     profile()->CreateHistoryService(true /* delete_file */, false /* no_db */);
   }
 
-  virtual void TearDown() {
+  virtual void TearDown() OVERRIDE {
     profile()->DestroyHistoryService();
     ChromeRenderViewHostTestHarness::TearDown();
-    io_thread_.Stop();
   }
 
   static bool ResourceLessThan(
       const ClientMalwareReportRequest::Resource* lhs,
       const ClientMalwareReportRequest::Resource* rhs) {
     return lhs->id() < rhs->id();
   }
 
   std::string WaitForSerializedReport(MalwareDetails* report) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MalwareDetails::FinishCollection, report));
     // Wait for the callback (SendSerializedMalwareDetails).
     DVLOG(1) << "Waiting for SendSerializedMalwareDetails";
-    MessageLoop::current()->Run();
+    base::RunLoop run_loop;
+    ui_manager_->SetRunLoopToQuit(&run_loop);
+    run_loop.Run();
     return ui_manager_->GetSerialized();
   }
 
   HistoryService* history_service() {
     return HistoryServiceFactory::GetForProfile(profile(),
                                                 Profile::EXPLICIT_ACCESS);
   }
 
  protected:
   void InitResource(UnsafeResource* resource,
@@ skipping 84 matching lines @@
                         history::RedirectList* redirects) {
     // The last item of the redirect chain has to be the final url when adding
     // to history backend.
     redirects->push_back(url);
     history_service()->AddPage(
         url, base::Time::Now(), static_cast<void*>(this), 0, GURL(),
         *redirects, content::PAGE_TRANSITION_TYPED, history::SOURCE_BROWSED,
         false);
   }
 
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread io_thread_;
   scoped_refptr<MockSafeBrowsingUIManager> ui_manager_;
 };
 
 // Tests creating a simple malware report.
 TEST_F(MalwareDetailsTest, MalwareSubResource) {
   // Start a load.
   controller().LoadURL(GURL(kLandingURL), content::Referrer(),
                        content::PAGE_TRANSITION_TYPED, std::string());
 
   UnsafeResource resource;
@@ skipping 80 matching lines @@
   child_node.url = GURL(kDOMChildURL);
   child_node.tag_name = "iframe";
   child_node.parent = GURL(kDOMParentURL);
   params.push_back(child_node);
   SafeBrowsingHostMsg_MalwareDOMDetails_Node parent_node;
   parent_node.url = GURL(kDOMParentURL);
   parent_node.children.push_back(GURL(kDOMChildURL));
   params.push_back(parent_node);
   report->OnReceivedMalwareDOMDetails(params);
 
-  MessageLoop::current()->RunUntilIdle();
-
   std::string serialized = WaitForSerializedReport(report);
   ClientMalwareReportRequest actual;
   actual.ParseFromString(serialized);
 
   ClientMalwareReportRequest expected;
   expected.set_malware_url(kMalwareURL);
   expected.set_page_url(kLandingURL);
   expected.set_referrer_url("");
 
   ClientMalwareReportRequest::Resource* pb_resource = expected.add_resources();
@@ skipping 110 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&FillCache,
                  make_scoped_refptr(profile()->GetRequestContext())));
 
   // The cache collection starts after the IPC from the DOM is fired.
   std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node> params;
   report->OnReceivedMalwareDOMDetails(params);
 
   // Let the cache callbacks complete
-  MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   DVLOG(1) << "Getting serialized report";
   std::string serialized = WaitForSerializedReport(report);
   ClientMalwareReportRequest actual;
   actual.ParseFromString(serialized);
 
   ClientMalwareReportRequest expected;
   expected.set_malware_url(kMalwareURL);
   expected.set_page_url(kLandingURL);
   expected.set_referrer_url("");
@@ skipping 50 matching lines @@
       ui_manager_.get(), web_contents(), resource,
       profile()->GetRequestContext());
 
   // No call to FillCache
 
   // The cache collection starts after the IPC from the DOM is fired.
   std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node> params;
   report->OnReceivedMalwareDOMDetails(params);
 
   // Let the cache callbacks complete
-  MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   DVLOG(1) << "Getting serialized report";
   std::string serialized = WaitForSerializedReport(report);
   ClientMalwareReportRequest actual;
   actual.ParseFromString(serialized);
 
   ClientMalwareReportRequest expected;
   expected.set_malware_url(kMalwareURL);
   expected.set_page_url(kLandingURL);
   expected.set_referrer_url("");
@@ skipping 28 matching lines @@
   UnsafeResource resource;
   InitResource(&resource, true, GURL(kMalwareURL));
   scoped_refptr<MalwareDetailsWrap> report = new MalwareDetailsWrap(
       ui_manager_.get(), web_contents(), resource, NULL);
 
   // The redirects collection starts after the IPC from the DOM is fired.
   std::vector<SafeBrowsingHostMsg_MalwareDOMDetails_Node> params;
   report->OnReceivedMalwareDOMDetails(params);
 
   // Let the redirects callbacks complete.
-  MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   std::string serialized = WaitForSerializedReport(report);
   ClientMalwareReportRequest actual;
   actual.ParseFromString(serialized);
 
   ClientMalwareReportRequest expected;
   expected.set_malware_url(kMalwareURL);
   expected.set_page_url(kLandingURL);
   expected.set_referrer_url("");
 
   ClientMalwareReportRequest::Resource* pb_resource = expected.add_resources();
   pb_resource->set_id(0);
   pb_resource->set_url(kLandingURL);
   pb_resource = expected.add_resources();
   pb_resource->set_id(1);
   pb_resource->set_parent_id(2);
   pb_resource->set_url(kMalwareURL);
   pb_resource = expected.add_resources();
   pb_resource->set_id(2);
   pb_resource->set_parent_id(3);
   pb_resource->set_url(kSecondRedirectURL);
   pb_resource = expected.add_resources();
   pb_resource->set_id(3);
   pb_resource->set_url(kFirstRedirectURL);
 
   VerifyResults(actual, expected);
 }