Only send the client-side phishing model to a renderer if its profile has SafeBrowsing enabled.

chrome/browser/safe_browsing/client_side_detection_service_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 <map>
 #include <queue>
 #include <string>
 
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
   MOCK_METHOD1(EndFetchModel, void(ClientModelStatus));
   MOCK_METHOD1(ScheduleFetchModel, void(int64));
 
   void Schedule(int64) {
     // Ignore the delay when testing.
     StartFetchModel();
   }
 
   void Disable(int) {
     // Ignore the status.
-    SetEnabled(false);
+    SetEnabledAndRefreshState(false);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockClientSideDetectionService);
 };
 
 ACTION(QuitCurrentMessageLoop) {
   MessageLoop::current()->Quit();
 }
 
@@ skipping 135 matching lines @@
   GURL phishing_url_;
   bool is_phishing_;
 };
 
 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.SetEnabled(true);
+  service.SetEnabledAndRefreshState(true);
 
   // The model fetch failed.
   SetModelFetchResponse("blamodel", false /* failure */);
   EXPECT_CALL(service, EndFetchModel(
       ClientSideDetectionService::MODEL_FETCH_FAILED))
       .WillOnce(QuitCurrentMessageLoop());
   service.StartFetchModel();
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(&service);
 
@@ skipping 89 matching lines @@
       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", true /* success */);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
-  csd_service_->SetEnabled(true);
+  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_.RunAllPending();
 }
 
 TEST_F(ClientSideDetectionServiceTest, SendClientReportPhishingRequest) {
   SetModelFetchResponse("bogus model", true /* success */);
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
-  csd_service_->SetEnabled(true);
+  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", true /* success */);
   EXPECT_FALSE(SendClientReportPhishingRequest(url, score));
 
@@ skipping 247 matching lines @@
   rule->set_weight(0.2f);
   EXPECT_FALSE(ClientSideDetectionService::ModelHasValidHashIds(model));
 
   rule->set_feature(2, 2);
   EXPECT_FALSE(ClientSideDetectionService::ModelHasValidHashIds(model));
 
   rule->set_feature(2, 1);
   EXPECT_TRUE(ClientSideDetectionService::ModelHasValidHashIds(model));
 }
 
-TEST_F(ClientSideDetectionServiceTest, SetEnabled) {
+TEST_F(ClientSideDetectionServiceTest, SetEnabledAndRefreshState) {
   // Check that the model isn't downloaded until the service is enabled.
   csd_service_.reset(ClientSideDetectionService::Create(NULL));
   EXPECT_FALSE(csd_service_->enabled());
   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
 
   // Use a MockClientSideDetectionService for the rest of the test, to avoid
   // the scheduling delay.
   MockClientSideDetectionService* service =
       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(), true /* success */);
   EXPECT_CALL(*service, ScheduleFetchModel(_))
       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
   EXPECT_CALL(*service, EndFetchModel(
       ClientSideDetectionService::MODEL_SUCCESS))
       .WillOnce(QuitCurrentMessageLoop());
-  csd_service_->SetEnabled(true);
+  csd_service_->SetEnabledAndRefreshState(true);
   EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
   msg_loop_.Run();  // EndFetchModel will quit the message loop.
   Mock::VerifyAndClearExpectations(service);
 
   // Check that enabling again doesn't request the model.
-  csd_service_->SetEnabled(true);
+  csd_service_->SetEnabledAndRefreshState(true);
   // No calls expected.
   Mock::VerifyAndClearExpectations(service);
 
   // Check that disabling the service cancels pending requests.
   EXPECT_CALL(*service, ScheduleFetchModel(_))
       .WillOnce(Invoke(service, &MockClientSideDetectionService::Schedule));
-  csd_service_->SetEnabled(false);
-  csd_service_->SetEnabled(true);
+  csd_service_->SetEnabledAndRefreshState(false);
+  csd_service_->SetEnabledAndRefreshState(true);
   Mock::VerifyAndClearExpectations(service);
   EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
-  csd_service_->SetEnabled(false);
+  csd_service_->SetEnabledAndRefreshState(false);
   EXPECT_TRUE(csd_service_->model_fetcher_.get() == NULL);
   msg_loop_.RunAllPending();
   // No calls expected.
   Mock::VerifyAndClearExpectations(service);
 
   // Requests always return false when the service is disabled.
   ClientPhishingResponse response;
   response.set_phishy(true);
   SetClientReportPhishingResponse(response.SerializeAsString(),
                                   true /* 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_->SetEnabled(true);
+  csd_service_->SetEnabledAndRefreshState(true);
   EXPECT_FALSE(SendClientReportPhishingRequest(GURL("http://a.com/"), 0.4f));
   Mock::VerifyAndClearExpectations(service);
 }
 
 TEST_F(ClientSideDetectionServiceTest, IsFalsePositiveResponse) {
   GURL url("http://www.google.com/");
   ClientPhishingResponse response;
 
   // If the response is not phishing is should never be a false positive.
   response.set_phishy(false);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(ClientSideDetectionService::IsFalsePositiveResponse(
       url, response));
 
   // If an entry in the whitelist matches the URL it should return true.
   response.clear_whitelist_expression();
   response.add_whitelist_expression("www.google.com/a/b.html");
   EXPECT_TRUE(ClientSideDetectionService::IsFalsePositiveResponse(
       url, response));
 }
 }  // namespace safe_browsing