Rename SafeBrowsingServiceTest in safe_browsing_test.cc to SafeBrowsingServerTest to avoid collisio…

chrome/browser/safe_browsing/safe_browsing_test.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.
 //
 // This test uses the safebrowsing test server published at
 // http://code.google.com/p/google-safe-browsing/ to test the safebrowsing
 // protocol implemetation. Details of the safebrowsing testing flow is
 // documented at
 // http://code.google.com/p/google-safe-browsing/wiki/ProtocolTesting
 //
@@ skipping 93 matching lines @@
       return false;
     }
     phishing_urls->push_back(phishing_url);
   }
   return true;
 }
 
 }  // namespace
 
 // This starts the browser and keeps status of states related to SafeBrowsing.
-class SafeBrowsingServiceTest : public InProcessBrowserTest {
+class SafeBrowsingServerTest : public InProcessBrowserTest {
  public:
-  SafeBrowsingServiceTest()
+  SafeBrowsingServerTest()
     : safe_browsing_service_(NULL),
       is_database_ready_(true),
       is_update_scheduled_(false),
       is_checked_url_in_db_(false),
       is_checked_url_safe_(false) {
   }
 
-  virtual ~SafeBrowsingServiceTest() {
+  virtual ~SafeBrowsingServerTest() {
   }
 
   void UpdateSafeBrowsingStatus() {
     ASSERT_TRUE(safe_browsing_service_);
     base::AutoLock lock(update_status_mutex_);
     last_update_ = safe_browsing_service_->protocol_manager_->last_update();
     is_update_scheduled_ =
         safe_browsing_service_->protocol_manager_->update_timer_.IsRunning();
   }
 
   void ForceUpdate() {
     content::WindowedNotificationObserver observer(
         chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
         content::Source<SafeBrowsingService>(safe_browsing_service_));
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTest::ForceUpdateOnIOThread,
+        base::Bind(&SafeBrowsingServerTest::ForceUpdateOnIOThread,
                    this));
     observer.Wait();
   }
 
   void ForceUpdateOnIOThread() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     ASSERT_TRUE(safe_browsing_service_);
     safe_browsing_service_->protocol_manager_->ForceScheduleNextUpdate(
         base::TimeDelta::FromSeconds(0));
   }
@@ skipping 114 matching lines @@
   // States associated with safebrowsing service updates.
   bool is_database_ready_;
   base::Time last_update_;
   bool is_update_scheduled_;
   // Indicates if there is a match between a URL's prefix and safebrowsing
   // database (thus potentially it is a phishing URL).
   bool is_checked_url_in_db_;
   // True if last verified URL is not a phishing URL and thus it is safe.
   bool is_checked_url_safe_;
 
-  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTest);
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServerTest);
 };
 
 // A ref counted helper class that handles callbacks between IO thread and UI
 // thread.
-class SafeBrowsingServiceTestHelper
-    : public base::RefCountedThreadSafe<SafeBrowsingServiceTestHelper>,
+class SafeBrowsingServerTestHelper
+    : public base::RefCountedThreadSafe<SafeBrowsingServerTestHelper>,
       public SafeBrowsingService::Client,
       public net::URLFetcherDelegate {
  public:
-  SafeBrowsingServiceTestHelper(SafeBrowsingServiceTest* safe_browsing_test,
-                                net::URLRequestContextGetter* request_context)
+  SafeBrowsingServerTestHelper(SafeBrowsingServerTest* safe_browsing_test,
+                               net::URLRequestContextGetter* request_context)
       : safe_browsing_test_(safe_browsing_test),
         response_status_(net::URLRequestStatus::FAILED),
         request_context_(request_context) {
   }
 
   // Callbacks for SafeBrowsingService::Client.
   virtual void OnCheckBrowseUrlResult(const GURL& url,
                                       SBThreatType threat_type) OVERRIDE {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     EXPECT_TRUE(safe_browsing_test_->is_checked_url_in_db());
     safe_browsing_test_->set_is_checked_url_safe(
         threat_type == SB_THREAT_TYPE_SAFE);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTestHelper::OnCheckUrlDone,
-                   this));
+        base::Bind(&SafeBrowsingServerTestHelper::OnCheckUrlDone, this));
   }
 
   virtual void OnBlockingPageComplete(bool proceed) {
     NOTREACHED() << "Not implemented.";
   }
 
   // Functions and callbacks related to CheckUrl. These are used to verify
   // phishing URLs.
   void CheckUrl(const GURL& url) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTestHelper::CheckUrlOnIOThread,
+        base::Bind(&SafeBrowsingServerTestHelper::CheckUrlOnIOThread,
                    this, url));
     content::RunMessageLoop();
   }
   void CheckUrlOnIOThread(const GURL& url) {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     safe_browsing_test_->CheckUrl(this, url);
     if (!safe_browsing_test_->is_checked_url_in_db()) {
       // Ends the checking since this URL's prefix is not in database.
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTestHelper::OnCheckUrlDone,
-                   this));
+        base::Bind(&SafeBrowsingServerTestHelper::OnCheckUrlDone, this));
     }
     // Otherwise, OnCheckUrlDone is called in OnUrlCheckResult since
     // safebrowsing service further fetches hashes from safebrowsing server.
   }
 
   void OnCheckUrlDone() {
     StopUILoop();
   }
 
   // Updates status from IO Thread.
   void CheckStatusOnIOThread() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     safe_browsing_test_->UpdateSafeBrowsingStatus();
     safe_browsing_test_->SafeBrowsingMessageLoop()->PostTask(FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTestHelper::CheckIsDatabaseReady, this));
+        base::Bind(&SafeBrowsingServerTestHelper::CheckIsDatabaseReady, this));
   }
 
   // Checks status in SafeBrowsing Thread.
   void CheckIsDatabaseReady() {
     EXPECT_EQ(MessageLoop::current(),
               safe_browsing_test_->SafeBrowsingMessageLoop());
     safe_browsing_test_->CheckIsDatabaseReady();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTestHelper::OnWaitForStatusUpdateDone,
+        base::Bind(&SafeBrowsingServerTestHelper::OnWaitForStatusUpdateDone,
                    this));
   }
 
   void OnWaitForStatusUpdateDone() {
     StopUILoop();
   }
 
   // Update safebrowsing status.
   void UpdateStatus() {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
-        base::Bind(&SafeBrowsingServiceTestHelper::CheckStatusOnIOThread,
-                   this));
+        base::Bind(&SafeBrowsingServerTestHelper::CheckStatusOnIOThread, this));
     // Will continue after OnWaitForStatusUpdateDone().
     content::RunMessageLoop();
   }
 
   // Calls test server to fetch database for verification.
   net::URLRequestStatus::Status FetchDBToVerify(
       const net::TestServer& test_server,
       int test_step) {
     // TODO(lzheng): Remove chunk_type=add once it is not needed by the server.
     std::string path = base::StringPrintf(
@@ skipping 28 matching lines @@
     source->GetResponseAsString(&response_data_);
     response_status_ = source->GetStatus().status();
     StopUILoop();
   }
 
   const std::string& response_data() {
     return response_data_;
   }
 
  private:
-  friend class base::RefCountedThreadSafe<SafeBrowsingServiceTestHelper>;
-  virtual ~SafeBrowsingServiceTestHelper() {}
+  friend class base::RefCountedThreadSafe<SafeBrowsingServerTestHelper>;
+  virtual ~SafeBrowsingServerTestHelper() {}
 
   // Stops UI loop after desired status is updated.
   void StopUILoop() {
     EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
     MessageLoopForUI::current()->Quit();
   }
 
   // Fetch a URL. If message_loop_started is true, starts the message loop
   // so the caller could wait till OnURLFetchComplete is called.
   net::URLRequestStatus::Status FetchUrl(const GURL& url) {
     url_fetcher_.reset(net::URLFetcher::Create(
         url, net::URLFetcher::GET, this));
     url_fetcher_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
     url_fetcher_->SetRequestContext(request_context_);
     url_fetcher_->Start();
     content::RunMessageLoop();
     return response_status_;
   }
 
-  base::OneShotTimer<SafeBrowsingServiceTestHelper> check_update_timer_;
-  SafeBrowsingServiceTest* safe_browsing_test_;
+  base::OneShotTimer<SafeBrowsingServerTestHelper> check_update_timer_;
+  SafeBrowsingServerTest* safe_browsing_test_;
   scoped_ptr<net::URLFetcher> url_fetcher_;
   std::string response_data_;
   net::URLRequestStatus::Status response_status_;
   net::URLRequestContextGetter* request_context_;
-  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTestHelper);
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServerTestHelper);
 };
 
 // See http://crbug.com/96459
-IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest,
-                       DISABLED_SafeBrowsingSystemTest) {
+IN_PROC_BROWSER_TEST_F(SafeBrowsingServerTest,
+                       DISABLED_SafeBrowsingServerTest) {
   LOG(INFO) << "Start test";
   ASSERT_TRUE(InitSafeBrowsingService());
 
   net::URLRequestContextGetter* request_context =
       browser()->profile()->GetRequestContext();
-  scoped_refptr<SafeBrowsingServiceTestHelper> safe_browsing_helper(
-      new SafeBrowsingServiceTestHelper(this, request_context));
+  scoped_refptr<SafeBrowsingServerTestHelper> safe_browsing_helper(
+      new SafeBrowsingServerTestHelper(this, request_context));
   int last_step = 0;
 
   // Waits and makes sure safebrowsing update is not happening.
   // The wait will stop once OnWaitForStatusUpdateDone in
   // safe_browsing_helper is called and status from safe_browsing_service_
   // is checked.
   safe_browsing_helper->UpdateStatus();
   EXPECT_TRUE(is_database_ready());
   EXPECT_FALSE(is_update_scheduled());
   EXPECT_TRUE(last_update().is_null());
@@ skipping 56 matching lines @@
               safe_browsing_helper->FetchDBToVerify(test_server(), step));
     EXPECT_GT(safe_browsing_helper->response_data().size(), 0U);
     last_step = step;
   }
 
   // Verifies with server if test is done and waits till server responses.
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             safe_browsing_helper->VerifyTestComplete(test_server(), last_step));
   EXPECT_EQ("yes", safe_browsing_helper->response_data());
 }