Add ChromeRenderViewHostTestHarness to get rid of the dependency from RVHTH to profile

chrome/browser/safe_browsing/malware_details_unittest.cc

 // Copyright (c) 2011 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/pickle.h"
 #include "base/time.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.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/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/test_url_request_context_getter.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/browser/browser_thread.h"
-#include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/test_tab_contents.h"
 #include "net/base/io_buffer.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"
@@ skipping 126 matching lines @@
     return serialized_;
   }
 
  private:
   std::string serialized_;
   DISALLOW_COPY_AND_ASSIGN(MockSafeBrowsingService);
 };
 
 }  // namespace.
 
-class MalwareDetailsTest : public RenderViewHostTestHarness {
+class MalwareDetailsTest : public ChromeRenderViewHostTestHarness {
  public:
   MalwareDetailsTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO),
         sb_service_(new MockSafeBrowsingService()) {
   }
 
   virtual void SetUp() {
-    RenderViewHostTestHarness::SetUp();
+    ChromeRenderViewHostTestHarness::SetUp();
     // The URLFetcher checks that the messageloop type is IO.
     ASSERT_TRUE(io_thread_.StartWithOptions(
         base::Thread::Options(MessageLoop::TYPE_IO, 0)));
 
-    profile_->CreateHistoryService(true /* delete_file */, false /* no_db */);
+    profile()->CreateHistoryService(true /* delete_file */, false /* no_db */);
   }
 
   virtual void TearDown() {
     io_thread_.Stop();
-    profile_->DestroyHistoryService();
-    RenderViewHostTestHarness::TearDown();
+    profile()->DestroyHistoryService();
+    ChromeRenderViewHostTestHarness::TearDown();
   }
 
   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,
         NewRunnableMethod(
             report, &MalwareDetails::FinishCollection));
     // Wait for the callback (SendSerializedMalwareDetails).
     DVLOG(1) << "Waiting for SendSerializedMalwareDetails";
     MessageLoop::current()->Run();
     return sb_service_->GetSerialized();
   }
 
   HistoryService* history_service() {
-    return profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
+    return profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   }
 
  protected:
   void InitResource(SafeBrowsingService::UnsafeResource* resource,
                     bool is_subresource,
                     const GURL& url) {
     resource->client = NULL;
     resource->url = url;
     resource->is_subresource = is_subresource;
     resource->threat_type = SafeBrowsingService::URL_MALWARE;
@@ skipping 415 matching lines @@
 TEST_F(MalwareDetailsTest, HistoryServiceUrls) {
   // Add content to history service.
   // There are two redirect urls before reacing malware url:
   // kFirstRedirectURL -> kSecondRedirectURL -> kMalwareURL
   GURL baseurl(kMalwareURL);
   history::RedirectList redirects;
   redirects.push_back(GURL(kFirstRedirectURL));
   redirects.push_back(GURL(kSecondRedirectURL));
   AddPageToHistory(baseurl, &redirects);
   // Wait for history service operation finished.
-  profile_->BlockUntilHistoryProcessesPendingRequests();
+  profile()->BlockUntilHistoryProcessesPendingRequests();
 
   controller().LoadURL(GURL(kLandingURL), GURL(), PageTransition::TYPED,
                        std::string());
 
   SafeBrowsingService::UnsafeResource resource;
   InitResource(&resource, true, GURL(kMalwareURL));
   scoped_refptr<MalwareDetailsWrap> report = new MalwareDetailsWrap(
       sb_service_.get(), contents(), resource, NULL);
 
   // The redirects collection starts after the IPC from the DOM is fired.
@@ skipping 22 matching lines @@
   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);
 }