Remove debug logging for SafeBrowsingServiceTest.StartAndStop.

chrome/browser/safe_browsing/safe_browsing_service_browsertest.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 creates a safebrowsing service using test safebrowsing database
 // and a test protocol manager. It is used to test logics in safebrowsing
 // service.
 
 #include <algorithm>
 
@@ skipping 381 matching lines @@
     sb_service->download_urlcheck_timeout_ms_ = ms;
   }
 
   void SetDownloadHashCheckTimeout(SafeBrowsingService* sb_service, int64 ms) {
     sb_service->download_hashcheck_timeout_ms_ = ms;
   }
 
   void CreateCSDService() {
     safe_browsing::ClientSideDetectionService* csd_service =
         safe_browsing::ClientSideDetectionService::Create(NULL);
-    LOG(INFO) << "CSDS created";
     SafeBrowsingService* sb_service =
         g_browser_process->safe_browsing_service();
     sb_service->csd_service_.reset(csd_service);
-    LOG(INFO) << "refreshing..";
     sb_service->RefreshState();
-    LOG(INFO) << "refreshed";
   }
 
  protected:
   StrictMock<MockObserver> observer_;
 
   // Temporary profile dir for test cases that create a second profile.  This is
   // owned by the SafeBrowsingServiceTest object so that it will not get
   // destructed until after the test Browser has been torn down, since the
   // ImportantFileWriter may still be modifying it after the Profile object has
   // been destroyed.
   ScopedTempDir temp_profile_dir_;
 
   // Waits for pending tasks on the IO thread to complete. This is useful
   // to wait for the SafeBrowsingService to finish loading/stopping.
   void WaitForIOThread() {
-    LOG(INFO) << "waiting for io thread";
     scoped_refptr<base::ThreadTestHelper> io_helper(new base::ThreadTestHelper(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
     ASSERT_TRUE(io_helper->Run());
-    LOG(INFO) << "done waiting";
   }
 
  private:
   TestSafeBrowsingDatabaseFactory db_factory_;
   TestSBProtocolManagerFactory pm_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTest);
 };
 
 namespace {
@@ skipping 273 matching lines @@
   client->CheckDownloadHash(full_hash);
 
   // 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) {
-  LOG(INFO) << __FUNCTION__;
   CreateCSDService();
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
   safe_browsing::ClientSideDetectionService* csd_service =
       sb_service->safe_browsing_detection_service();
-  LOG(INFO) << "get prefs";
   PrefService* pref_service = browser()->profile()->GetPrefs();
 
   ASSERT_TRUE(sb_service != NULL);
   ASSERT_TRUE(csd_service != NULL);
   ASSERT_TRUE(pref_service != NULL);
 
-  LOG(INFO) << "checking pref";
   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.
-  LOG(INFO) << "creating ScopedTempDir";
   ASSERT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
-  LOG(INFO) << "created " << temp_profile_dir_.path().LossyDisplayName();
-  LOG(INFO) << "creating profile2";
   scoped_ptr<Profile> profile2(Profile::CreateProfile(
       temp_profile_dir_.path(), NULL, Profile::CREATE_MODE_SYNCHRONOUS));
   ASSERT_TRUE(profile2.get() != NULL);
-  LOG(INFO) << "get prefs2";
   PrefService* pref_service2 = profile2->GetPrefs();
-  LOG(INFO) << "checking pref2";
   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());
 
-  LOG(INFO) << "setting pref";
   // 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());
 
-  LOG(INFO) << "setting pref2";
   // 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());
 
-  LOG(INFO) << "setting pref2";
   // Turn it back on. SBS comes back.
   pref_service2->SetBoolean(prefs::kSafeBrowsingEnabled, true);
   WaitForIOThread();
   EXPECT_TRUE(sb_service->enabled());
   EXPECT_TRUE(csd_service->enabled());
 
-  LOG(INFO) << "deleting profile2";
   // Delete the Profile. SBS stops again.
   pref_service2 = NULL;
   profile2.reset();
   WaitForIOThread();
   EXPECT_FALSE(sb_service->enabled());
   EXPECT_FALSE(csd_service->enabled());
-  LOG(INFO) << __FUNCTION__ << " done";
 }
 
 }  // namespace
 
 class SafeBrowsingServiceCookieTest : public InProcessBrowserTest {
  public:
   SafeBrowsingServiceCookieTest() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) {
     InProcessBrowserTest::SetUpCommandLine(command_line);
@@ skipping 101 matching lines @@
 // save cookies.
 IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceCookieTest, TestSBUpdateCookies) {
   ui_test_utils::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE,
       content::Source<SafeBrowsingService>(sb_service_.get()));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SafeBrowsingServiceCookieTest::ForceUpdate, this));
   observer.Wait();
 }