Add "enabled" state to the ClientSideDetectionService.

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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.
 //
 // This test creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_temp_dir.h"
 #include "crypto/sha2.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/browser_thread.h"
@@ skipping 362 matching lines @@
   }
 
   void SetDownloadUrlCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
     sb_service->download_urlcheck_timeout_ms_ = ms;
   }
 
   void SetDownloadHashCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
     sb_service->download_hashcheck_timeout_ms_ = ms;
   }
 
+  safe_browsing::ClientSideDetectionService* CreateCSDService() {
+    safe_browsing::ClientSideDetectionService* csd_service =
+        safe_browsing::ClientSideDetectionService::Create(NULL);
+    SafeBrowsingService* sb_service =
+        g_browser_process->safe_browsing_service();
+    sb_service->csd_service_ = csd_service;
+    sb_service->RefreshState();
+    return csd_service;
+  }
+
  protected:
   StrictMock<MockObserver> observer_;
 
   // Waits for pending tasks on the IO thread to complete. This is useful
   // to wait for the SafeBrowsingService to finish loading/stopping.
   void WaitForIOThread() {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, NewRunnableFunction(&QuitFromIOThread));
     ui_test_utils::RunMessageLoop();  // Will stop from |QuitUIThread|.
   }
@@ skipping 282 matching lines @@
 
   // There should be a timeout and the hash would be considered as safe.
   EXPECT_EQ(SafeBrowsingService::SAFE, client->GetResult());
 
   // Need to set the timeout back to the default value.
   SetDownloadHashCheckTimeout(sb_service, default_hashcheck_timeout);
 }
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, StartAndStop) {
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
+  scoped_ptr<safe_browsing::ClientSideDetectionService> csd_service(
+      CreateCSDService());
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
+  ASSERT_TRUE(sb_service != NULL);
+  ASSERT_TRUE(csd_service != NULL);
+  ASSERT_TRUE(pref_service != NULL);
+
   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
 
   // SBS might still be starting, make sure this doesn't flake.
   WaitForIOThread();
   EXPECT_TRUE(sb_service->enabled());
+  EXPECT_TRUE(csd_service->enabled());
 
   // Add a new Profile. SBS should keep running.
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   scoped_ptr<Profile> profile2(Profile::CreateProfile(temp_dir.path()));
   ASSERT_TRUE(profile2.get() != NULL);
   PrefService* pref_service2 = profile2->GetPrefs();
   EXPECT_TRUE(pref_service2->GetBoolean(prefs::kSafeBrowsingEnabled));
   // We don't expect the state to have changed, but if it did, wait for it.
   WaitForIOThread();
   EXPECT_TRUE(sb_service->enabled());
+  EXPECT_TRUE(csd_service->enabled());
 
   // Change one of the prefs. SBS should keep running.
   pref_service->SetBoolean(prefs::kSafeBrowsingEnabled, false);
   WaitForIOThread();
   EXPECT_TRUE(sb_service->enabled());
+  EXPECT_TRUE(csd_service->enabled());
 
   // Change the other pref. SBS should stop now.
   pref_service2->SetBoolean(prefs::kSafeBrowsingEnabled, false);
   WaitForIOThread();
   EXPECT_FALSE(sb_service->enabled());
+  EXPECT_FALSE(csd_service->enabled());
 
   // Turn it back on. SBS comes back.
   pref_service2->SetBoolean(prefs::kSafeBrowsingEnabled, true);
   WaitForIOThread();
   EXPECT_TRUE(sb_service->enabled());
+  EXPECT_TRUE(csd_service->enabled());
 
   // Delete the Profile. SBS stops again.
   pref_service2 = NULL;
   profile2.reset();
   WaitForIOThread();
   EXPECT_FALSE(sb_service->enabled());
+  EXPECT_FALSE(csd_service->enabled());
 }
 
 }  // namespace