[sync] Allow FakeURLFetcher to return an arbitrary URLRequestStatus

chrome/browser/safe_browsing/client_side_detection_service_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 <map>
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 89 matching lines @@
     csd_service_->SendClientReportMalwareRequest(
         request.release(),
         base::Bind(&ClientSideDetectionServiceTest::SendMalwareRequestDone,
                    base::Unretained(this)));
     phishing_url_ = url;
     msg_loop_.Run();  // Waits until callback is called.
     return is_malware_;
   }
 
   void SetModelFetchResponse(std::string response_data,
-                             net::HttpStatusCode response_code) {
+                             net::HttpStatusCode response_code,
+                             net::URLRequestStatus::Status status) {
     factory_->SetFakeResponse(GURL(ClientSideDetectionService::kClientModelUrl),
-                              response_data,
-                              response_code);
+                              response_data, response_code, status);
   }
 
   void SetClientReportPhishingResponse(std::string response_data,
-                                       net::HttpStatusCode response_code) {
+                                       net::HttpStatusCode response_code,
+                                       net::URLRequestStatus::Status status) {
     factory_->SetFakeResponse(
         ClientSideDetectionService::GetClientReportUrl(
             ClientSideDetectionService::kClientReportPhishingUrl),
-        response_data,
-        response_code);
+        response_data, response_code, status);
   }
 
   void SetClientReportMalwareResponse(std::string response_data,
-                                      net::HttpStatusCode response_code) {
+                                      net::HttpStatusCode response_code,
+                                      net::URLRequestStatus::Status status) {
     factory_->SetFakeResponse(
         ClientSideDetectionService::GetClientReportUrl(
             ClientSideDetectionService::kClientReportMalwareUrl),
-        response_data,
-        response_code);
+        response_data, response_code, status);
   }
 
   int GetNumReports(std::queue<base::Time>* report_times) {
     return csd_service_->GetNumReports(report_times);
   }
 
   std::queue<base::Time>& GetPhishingReportTimes() {
     return csd_service_->phishing_report_times_;
   }
 
@@ skipping 111 matching lines @@
 
 TEST_F(ClientSideDetectionServiceTest, FetchModelTest) {
   // We don't want to use a real service class here because we can't call
   // the real EndFetchModel.  It would reschedule a reload which might
   // make the test flaky.
   MockClientSideDetectionService service;
   EXPECT_CALL(service, ScheduleFetchModel(_)).Times(1);
   service.SetEnabledAndRefreshState(true);
 
   // The model fetch failed.
-  SetModelFetchResponse("blamodel", net::HTTP_INTERNAL_SERVER_ERROR);
+  SetModelFetchResponse("blamodel", net::HTTP_INTERNAL_SERVER_ERROR,
+                        net::URLRequestStatus::FAILED);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_FETCH_FAILED))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Empty model file.
-  SetModelFetchResponse(std::string(), net::HTTP_OK);
+  SetModelFetchResponse(std::string(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(ClientSideDetectionService::MODEL_EMPTY))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Model is too large.
   SetModelFetchResponse(
       std::string(ClientSideDetectionService::kMaxModelSizeBytes + 1, 'x'),
-      net::HTTP_OK);
+      net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_TOO_LARGE))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Unable to parse the model file.
-  SetModelFetchResponse("Invalid model file", net::HTTP_OK);
+  SetModelFetchResponse("Invalid model file", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_PARSE_ERROR))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Model that is missing some required fields (missing the version field).
   ClientSideModel model;
   model.set_max_words_per_term(4);
-  SetModelFetchResponse(model.SerializePartialAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializePartialAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_MISSING_FIELDS))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Model that points to hashes that don't exist.
   model.set_version(10);
   model.add_hashes("bla");
   model.add_page_term(1);  // Should be 0 instead of 1.
-  SetModelFetchResponse(model.SerializePartialAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializePartialAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_BAD_HASH_IDS))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
   model.set_page_term(0, 0);
 
   // Model version number is wrong.
   model.set_version(-1);
-  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_INVALID_VERSION_NUMBER))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Normal model.
   model.set_version(10);
-  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_SUCCESS))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Model version number is decreasing.  Set the model version number of the
   // model that is currently loaded in the service object to 11.
   service.model_.reset(new ClientSideModel(model));
   service.model_->set_version(11);
-  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_INVALID_VERSION_NUMBER))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
   // Model version hasn't changed since the last reload.
   service.model_->set_version(10);
-  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_NOT_CHANGED))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 }
 
 TEST_F(ClientSideDetectionServiceTest, ServiceObjectDeletedBeforeCallbackDone) {
-  SetModelFetchResponse("bogus model", net::HTTP_OK);
+  SetModelFetchResponse("bogus model", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
   csd_service_->SetEnabledAndRefreshState(true);
   EXPECT_TRUE(csd_service_.get() != NULL);
   // We delete the client-side detection service class even though the callbacks
   // haven't run yet.
   csd_service_.reset();
   // Waiting for the callbacks to run should not crash even if the service
   // object is gone.
   msg_loop_.RunUntilIdle();
 }
 
 TEST_F(ClientSideDetectionServiceTest, SendClientReportPhishingRequest) {
-  SetModelFetchResponse("bogus model", net::HTTP_OK);
+  SetModelFetchResponse("bogus model", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
   csd_service_->SetEnabledAndRefreshState(true);
 
   GURL url("http://a.com/");
   float score = 0.4f;  // Some random client score.
 
   base::Time before = base::Time::Now();
 
   // Invalid response body from the server.
-  SetClientReportPhishingResponse("invalid proto response", net::HTTP_OK);
+  SetClientReportPhishingResponse("invalid proto response", net::HTTP_OK,
+                                  net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SendClientReportPhishingRequest(url, score));
 
   // Normal behavior.
   ClientPhishingResponse response;
   response.set_phishy(true);
-  SetClientReportPhishingResponse(response.SerializeAsString(),
-                                  net::HTTP_OK);
+  SetClientReportPhishingResponse(response.SerializeAsString(), net::HTTP_OK,
+                                  net::URLRequestStatus::SUCCESS);
   EXPECT_TRUE(SendClientReportPhishingRequest(url, score));
 
   // This request will fail
   GURL second_url("http://b.com/");
   response.set_phishy(false);
   SetClientReportPhishingResponse(response.SerializeAsString(),
-                                  net::HTTP_INTERNAL_SERVER_ERROR);
+                                  net::HTTP_INTERNAL_SERVER_ERROR,
+                                  net::URLRequestStatus::FAILED);
   EXPECT_FALSE(SendClientReportPhishingRequest(second_url, score));
 
   base::Time after = base::Time::Now();
 
   // Check that we have recorded all 3 requests within the correct time range.
   std::queue<base::Time>& report_times = GetPhishingReportTimes();
   EXPECT_EQ(3U, report_times.size());
   while (!report_times.empty()) {
     base::Time time = report_times.back();
     report_times.pop();
     EXPECT_LE(before, time);
     EXPECT_GE(after, time);
   }
 
   // Only the first url should be in the cache.
   bool is_phishing;
   EXPECT_TRUE(csd_service_->IsInCache(url));
   EXPECT_TRUE(csd_service_->GetValidCachedResult(url, &is_phishing));
   EXPECT_TRUE(is_phishing);
   EXPECT_FALSE(csd_service_->IsInCache(second_url));
 }
 
 TEST_F(ClientSideDetectionServiceTest, SendClientReportMalwareRequest) {
-  SetModelFetchResponse("bogus model", net::HTTP_OK);
+  SetModelFetchResponse("bogus model", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
   csd_service_->SetEnabledAndRefreshState(true);
   GURL url("http://a.com/");
 
   base::Time before = base::Time::Now();
   // Invalid response body from the server.
-  SetClientReportMalwareResponse("invalid proto response", net::HTTP_OK);
+  SetClientReportMalwareResponse("invalid proto response", net::HTTP_OK,
+                                 net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 
   // Missing bad_url.
   ClientMalwareResponse response;
   response.set_blacklist(true);
-  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK);
+  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
+                                 net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 
   // Normal behavior.
   response.set_blacklist(true);
   response.set_bad_url("http://response-bad.com/");
-  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK);
+  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
+                                 net::URLRequestStatus::SUCCESS);
   EXPECT_TRUE(SendClientReportMalwareRequest(url));
   CheckConfirmedMalwareUrl(GURL("http://response-bad.com/"));
 
   // This request will fail
   response.set_blacklist(false);
   SetClientReportMalwareResponse(response.SerializeAsString(),
-                                 net::HTTP_INTERNAL_SERVER_ERROR);
+                                 net::HTTP_INTERNAL_SERVER_ERROR,
+                                 net::URLRequestStatus::FAILED);
   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 
   // server blacklist decision is false, and response is succesful
   response.set_blacklist(false);
-  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK);
+  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
+                                 net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 
   // Check that we have recorded all 4 requests within the correct time range.
   base::Time after = base::Time::Now();
   std::queue<base::Time>& report_times = GetMalwareReportTimes();
   EXPECT_EQ(4U, report_times.size());
 
   // Another normal behavior will fail because of the limit is hit
   response.set_blacklist(true);
-  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK);
+  SetClientReportMalwareResponse(response.SerializeAsString(), net::HTTP_OK,
+                                 net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SendClientReportMalwareRequest(url));
 
   report_times = GetMalwareReportTimes();
   EXPECT_EQ(4U, report_times.size());
   while (!report_times.empty()) {
     base::Time time = report_times.back();
     report_times.pop();
     EXPECT_LE(before, time);
     EXPECT_GE(after, time);
   }
 }
 
 TEST_F(ClientSideDetectionServiceTest, GetNumReportTest) {
-  SetModelFetchResponse("bogus model", net::HTTP_OK);
+  SetModelFetchResponse("bogus model", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 
   std::queue<base::Time>& report_times = GetPhishingReportTimes();
   base::Time now = base::Time::Now();
   base::TimeDelta twenty_five_hours = base::TimeDelta::FromHours(25);
   report_times.push(now - twenty_five_hours);
   report_times.push(now - twenty_five_hours);
   report_times.push(now);
   report_times.push(now);
 
   EXPECT_EQ(2, GetNumReports(&report_times));
 }
 
 TEST_F(ClientSideDetectionServiceTest, CacheTest) {
-  SetModelFetchResponse("bogus model", net::HTTP_OK);
+  SetModelFetchResponse("bogus model", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 
   TestCache();
 }
 
 TEST_F(ClientSideDetectionServiceTest, IsPrivateIPAddress) {
-  SetModelFetchResponse("bogus model", net::HTTP_OK);
+  SetModelFetchResponse("bogus model", net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
 
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("10.1.2.3"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("127.0.0.1"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("172.24.3.4"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("192.168.1.1"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("fc00::"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("fec0::"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("fec0:1:2::3"));
   EXPECT_TRUE(csd_service_->IsPrivateIPAddress("::1"));
@@ skipping 110 matching lines @@
       new StrictMock<MockClientSideDetectionService>();
   csd_service_.reset(service);
   EXPECT_FALSE(csd_service_->enabled());
   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
   // No calls expected yet.
   Mock::VerifyAndClearExpectations(service);
 
   ClientSideModel model;
   model.set_version(10);
   model.set_max_words_per_term(4);
-  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK);
+  SetModelFetchResponse(model.SerializeAsString(), net::HTTP_OK,
+                        net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*service, ScheduleFetchModel(_))
       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
   EXPECT_CALL(*service, EndFetchModel(
       ClientSideDetectionService::MODEL_SUCCESS))
       .WillOnce(QuitCurrentMessageLoop());
   csd_service_->SetEnabledAndRefreshState(true);
   EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(service);
 
@@ skipping 11 matching lines @@
   EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
   csd_service_->SetEnabledAndRefreshState(false);
   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
   msg_loop_.RunUntilIdle();
   // No calls expected.
   Mock::VerifyAndClearExpectations(service);
 
   // Requests always return false when the service is disabled.
   ClientPhishingResponse response;
   response.set_phishy(true);
-  SetClientReportPhishingResponse(response.SerializeAsString(),
-                                  net::HTTP_OK);
+  SetClientReportPhishingResponse(response.SerializeAsString(), net::HTTP_OK,
+                                  net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SendClientReportPhishingRequest(GURL("http://a.com/"), 0.4f));
 
   // Pending requests also return false if the service is disabled before they
   // report back.
   EXPECT_CALL(*service, ScheduleFetchModel(_))
       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
   EXPECT_CALL(*service, EndFetchModel(
       ClientSideDetectionService::MODEL_NOT_CHANGED))
       .WillOnce(Invoke(service, &MockClientSideDetectionService::Disable));
   csd_service_->SetEnabledAndRefreshState(true);
   EXPECT_FALSE(SendClientReportPhishingRequest(GURL("http://a.com/"), 0.4f));
   Mock::VerifyAndClearExpectations(service);
 }
 }  // namespace safe_browsing