Replace SafeBrowsing MAC with downloads over SSL.

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 34 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/net_log.h"
 #include "net/test/python_utils.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace {
 
-const FilePath::CharType kDataFile[] = FILE_PATH_LITERAL("testing_input.dat");
+const FilePath::CharType kDataFile[] =
+    FILE_PATH_LITERAL("testing_input_nomac.dat");
 const char kUrlVerifyPath[] = "/safebrowsing/verify_urls";
 const char kDBVerifyPath[] = "/safebrowsing/verify_database";
 const char kDBResetPath[] = "/reset";
 const char kTestCompletePath[] = "/test_complete";
 
 struct PhishingUrl {
   std::string url;
   std::string list_name;
   bool is_phishing;
 };
@@ skipping 133 matching lines @@
 
 const char SafeBrowsingTestServer::kHost_[] = "localhost";
 const int SafeBrowsingTestServer::kPort_ = 40102;
 
 // This starts the browser and keeps status of states related to SafeBrowsing.
 class SafeBrowsingServiceTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServiceTest()
     : safe_browsing_service_(NULL),
       is_database_ready_(true),
-      is_initial_request_(false),
       is_update_scheduled_(false),
       is_checked_url_in_db_(false),
       is_checked_url_safe_(false) {
   }
 
   virtual ~SafeBrowsingServiceTest() {
   }
 
   void UpdateSafeBrowsingStatus() {
     ASSERT_TRUE(safe_browsing_service_);
     base::AutoLock lock(update_status_mutex_);
-    is_initial_request_ =
-        safe_browsing_service_->protocol_manager_->is_initial_request();
     last_update_ = safe_browsing_service_->protocol_manager_->last_update();
     is_update_scheduled_ =
         safe_browsing_service_->protocol_manager_->update_timer_.IsRunning();
   }
 
   void ForceUpdate() {
     ASSERT_TRUE(safe_browsing_service_);
     safe_browsing_service_->protocol_manager_->ForceScheduleNextUpdate(0);
   }
 
@@ skipping 30 matching lines @@
   bool is_checked_url_safe() {
     base::AutoLock l(update_status_mutex_);
     return is_checked_url_safe_;
   }
 
   bool is_database_ready() {
     base::AutoLock l(update_status_mutex_);
     return is_database_ready_;
   }
 
-  bool is_initial_request() {
-    base::AutoLock l(update_status_mutex_);
-    return is_initial_request_;
-  }
-
   base::Time last_update() {
     base::AutoLock l(update_status_mutex_);
     return last_update_;
   }
 
   bool is_update_scheduled() {
     base::AutoLock l(update_status_mutex_);
     return is_update_scheduled_;
   }
 
@@ skipping 19 matching lines @@
 
     // TODO(lzheng): The test server does not understand download related
     // requests. We need to fix the server.
     command_line->AppendSwitch(switches::kSbDisableDownloadProtection);
 
     // TODO(gcasto): Generate new testing data that includes the
     // client-side phishing whitelist.
     command_line->AppendSwitch(
         switches::kDisableClientSidePhishingDetection);
 
-    // In this test, we fetch SafeBrowsing data and Mac key from the same
-    // server. Although in real production, they are served from different
-    // servers.
+    // Point to the testing server for all SafeBrowsing requests.
     std::string url_prefix =
         base::StringPrintf("http://%s:%d/safebrowsing",
                            SafeBrowsingTestServer::Host(),
                            SafeBrowsingTestServer::Port());
-    command_line->AppendSwitchASCII(switches::kSbInfoURLPrefix, url_prefix);
-    command_line->AppendSwitchASCII(switches::kSbMacKeyURLPrefix, url_prefix);
+    command_line->AppendSwitchASCII(switches::kSbURLPrefix, url_prefix);
   }
 
   void SetTestStep(int step) {
     std::string test_step = base::StringPrintf("test_step=%d", step);
     safe_browsing_service_->protocol_manager_->set_additional_query(test_step);
   }
 
  private:
   SafeBrowsingService* safe_browsing_service_;
 
   // Protects all variables below since they are read on UI thread
   // but updated on IO thread or safebrowsing thread.
   base::Lock update_status_mutex_;
 
   // States associated with safebrowsing service updates.
   bool is_database_ready_;
-  bool is_initial_request_;
   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);
 };
@@ skipping 214 matching lines @@
 
   // Make sure the server is running.
   safe_browsing_helper->WaitTillServerReady(server_host, server_port);
 
   // 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->WaitForStatusUpdate(0);
   EXPECT_TRUE(is_database_ready());
-  EXPECT_TRUE(is_initial_request());
   EXPECT_FALSE(is_update_scheduled());
   EXPECT_TRUE(last_update().is_null());
   // Starts updates. After each update, the test will fetch a list of URLs with
   // expected results to verify with safebrowsing service. If there is no error,
   // the test moves on to the next step to get more update chunks.
   // This repeats till there is no update data.
   for (int step = 1;; step++) {
     // Every step should be a fresh start.
     SCOPED_TRACE(base::StringPrintf("step=%d", step));
     EXPECT_TRUE(is_database_ready());
     EXPECT_FALSE(is_update_scheduled());
 
     // Starts safebrowsing update on IO thread. Waits till scheduled
     // update finishes. Stops waiting after kMaxWaitSecPerStep if the update
     // could not finish.
     base::Time now = base::Time::Now();
     SetTestStep(step);
     safe_browsing_helper->ForceUpdate();
 
     do {
       // Periodically pull the status.
       safe_browsing_helper->WaitForStatusUpdate(
           TestTimeouts::tiny_timeout_ms());
-    } while (is_update_scheduled() || is_initial_request() ||
-             !is_database_ready());
+    } while (is_update_scheduled() || !is_database_ready());
 
 
     if (last_update() < now) {
       // This means no data available anymore.
       break;
     }
 
     // Fetches URLs to verify and waits till server responses with data.
     EXPECT_EQ(net::URLRequestStatus::SUCCESS,
               safe_browsing_helper->FetchUrlsToVerify(server_host,
@@ skipping 35 matching lines @@
   }
 
   // Verifies with server if test is done and waits till server responses.
   EXPECT_EQ(net::URLRequestStatus::SUCCESS,
             safe_browsing_helper->VerifyTestComplete(server_host,
                                                      server_port,
                                                      last_step));
   EXPECT_EQ("yes", safe_browsing_helper->response_data());
   test_server.Stop();
 }