Add "enabled" state to the ClientSideDetectionService.

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"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/common/safe_browsing/client_model.pb.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/test/base/testing_browser_process_test.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/url_fetcher.h"
 #include "content/test/test_url_fetcher_factory.h"
 #include "crypto/sha2.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
+using ::testing::Invoke;
 using ::testing::Mock;
+using ::testing::StrictMock;
 
 namespace safe_browsing {
 namespace {
 class MockClientSideDetectionService : public ClientSideDetectionService {
  public:
   MockClientSideDetectionService() : ClientSideDetectionService(NULL) {}
   virtual ~MockClientSideDetectionService() {}
 
   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);
+  }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockClientSideDetectionService);
 };
 
 ACTION(QuitCurrentMessageLoop) {
   MessageLoop::current()->Quit();
 }
+
 }  // namespace
 
 class ClientSideDetectionServiceTest : public TestingBrowserProcessTest {
  protected:
   virtual void SetUp() {
     file_thread_.reset(new BrowserThread(BrowserThread::FILE, &msg_loop_));
 
     factory_.reset(new FakeURLFetcherFactory());
 
     browser_thread_.reset(new BrowserThread(BrowserThread::UI, &msg_loop_));
@@ skipping 109 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);
 
   // 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);
   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);
 
   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 246 matching lines @@
   rule->add_feature(-1);
   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) {
+  // 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);
+  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);
+  // 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);
+  Mock::VerifyAndClearExpectations(service);
+  EXPECT_TRUE(csd_service_->model_fetcher_.get() != NULL);
+  csd_service_->SetEnabled(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);
+  EXPECT_FALSE(SendClientReportPhishingRequest(GURL("http://a.com/"), 0.4f));
+  Mock::VerifyAndClearExpectations(service);
+}
+
 }  // namespace safe_browsing