First change to add safebrowsing service test. ...

chrome/browser/safe_browsing/safe_browsing_browsertest.cc

+// Copyright (c) 2010 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 "base/command_line.h"
+#include "base/lock.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/renderer_host/resource_dispatcher_host.h"
+#include "chrome/browser/safe_browsing/protocol_manager.h"
+#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/test/in_process_browser_test.h"
+#include "chrome/test/ui_test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// This starts the browser and keeps status of states related to SafeBrowsing.
+class SafeBrowsingServiceTest : public InProcessBrowserTest {
+ public:
+  SafeBrowsingServiceTest()
+    : safe_browsing_service_(NULL),
+      is_update_in_progress_(false),
+      is_initial_request_(false),
+      is_update_scheduled_(false),
+      is_url_match_in_db_(false) {
+  }
+
+  void UpdateSafeBrowsingStatus() {
+    CHECK(safe_browsing_service_);
+    AutoLock lock(update_status_mutex_);
+    is_update_in_progress_ = safe_browsing_service_->IsUpdateInProgress();
+    is_initial_request_ =
+        safe_browsing_service_->protocol_manager_->is_initial_request();
+    last_update_ = safe_browsing_service_->protocol_manager_->last_update();
+    is_update_scheduled_ =
+        safe_browsing_service_->protocol_manager_->update_timer_.IsRunning();
+  }
+
+  void CheckUrl(SafeBrowsingService::Client* helper, const GURL& url) {
+    CHECK(safe_browsing_service_);
+    AutoLock lock(update_status_mutex_);
+    if (!safe_browsing_service_->CheckUrl(url, helper)) {
+      safe_browsing_service_->CancelCheck(helper);
+      is_url_match_in_db_ = false;
+    }
+    is_url_match_in_db_ = true;
+  }
+
+  bool is_url_match_in_db() {
+    AutoLock l(update_status_mutex_);
+    return is_url_match_in_db_;
+  }
+
+  bool is_update_in_progress() {
+    AutoLock l(update_status_mutex_);
+    return is_update_in_progress_;
+  }
+
+  bool is_initial_request() {
+    AutoLock l(update_status_mutex_);
+    return is_initial_request_;
+  }
+
+  base::Time last_update() {
+    AutoLock l(update_status_mutex_);
+    return last_update_;
+  }
+
+  bool is_update_scheduled() {
+    AutoLock l(update_status_mutex_);
+    return is_update_scheduled_;
+  }
+
+ protected:
+  void InitSafeBrowsingService() {
+    safe_browsing_service_ =
+        g_browser_process->resource_dispatcher_host()->safe_browsing_service();
+  }
+
+  virtual void SetUpCommandLine(CommandLine* command_line) {
+    // Makes sure the auto update is not triggered. This test will force the
+    // update when needed.
+    command_line->AppendSwitch(switches::kSbDisableAutoUpdate);
+  }
+
+ private:
+  SafeBrowsingService* safe_browsing_service_;
+
+  // Protects all variables below since they are updated on IO thread but
+  // read on UI thread.
+  Lock update_status_mutex_;
+  // States associated with safebrowsing service updates.
+  bool is_update_in_progress_;
+  bool is_initial_request_;
+  base::Time last_update_;
+  bool is_update_scheduled_;
+  // Indicates if there is a match between a URL's prefix and safebrowsing
+  // database (thus potentially it is a phishing url).
+  bool is_url_match_in_db_;
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTest);
+};
+
+// A ref counted helper class that handles callbacks between IO thread and UI
+// thread.
+class SafeBrowsingServiceTestHelper
+    : public base::RefCountedThreadSafe<SafeBrowsingServiceTestHelper>,
+      public SafeBrowsingService::Client {
+ public:
+  explicit SafeBrowsingServiceTestHelper(
+      SafeBrowsingServiceTest* safe_browsing_test)
+      : safe_browsing_test_(safe_browsing_test) {
+  }
+
+  // Callbacks for SafeBrowsingService::Client. Not implemented yet.
+  virtual void OnUrlCheckResult(const GURL& url,
+                                SafeBrowsingService::UrlCheckResult result) {
+    NOTREACHED() << "Not implemented.";
+  }
+  virtual void OnBlockingPageComplete(bool proceed) {
+    NOTREACHED() << "Not implemented.";
+  }
+
+  // Functions and callbacks related to CheckUrl. These are used to verify if
+  // a URL is a phishing URL.
+  void CheckUrl(const GURL& url) {
+    ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, NewRunnableMethod(this,
+        &SafeBrowsingServiceTestHelper::CheckUrlOnIOThread, url));
+  }
+  void CheckUrlOnIOThread(const GURL& url) {
+    CHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+    safe_browsing_test_->CheckUrl(this, url);
+    ChromeThread::PostTask(ChromeThread::UI, FROM_HERE, NewRunnableMethod(this,
+        &SafeBrowsingServiceTestHelper::OnCheckUrlOnIOThreadDone));
+  }
+  void OnCheckUrlOnIOThreadDone() {
+    StopUILoop();
+  }
+
+  // Functions and callbacks related to safebrowsing server status.
+  void CheckStatusOnIOThread() {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+    safe_browsing_test_->UpdateSafeBrowsingStatus();
+    ChromeThread::PostTask(ChromeThread::UI, FROM_HERE, NewRunnableMethod(this,
+        &SafeBrowsingServiceTestHelper::OnCheckStatusOnIOThreadDone));
+  }
+  void OnCheckStatusOnIOThreadDone() {
+    StopUILoop();
+  }
+  void CheckStatusAfterDelay(int64 wait_time_sec) {
+    ChromeThread::PostDelayedTask(
+        ChromeThread::IO,
+        FROM_HERE,
+        NewRunnableMethod(this,
+            &SafeBrowsingServiceTestHelper::CheckStatusOnIOThread),
+        wait_time_sec * 1000);
+  }
+
+ private:
+  // Stops UI loop after desired status is updated.
+  void StopUILoop() {
+    CHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+    MessageLoopForUI::current()->Quit();
+  }
+
+  base::OneShotTimer<SafeBrowsingServiceTestHelper> check_update_timer_;
+  SafeBrowsingServiceTest* safe_browsing_test_;
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingServiceTestHelper);
+};
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingServiceTest, SafeBrowsingSystemTest) {
+  InitSafeBrowsingService();
+  scoped_refptr<SafeBrowsingServiceTestHelper> safe_browsing_helper =
+      new SafeBrowsingServiceTestHelper(this);
+
+  // Waits for 1 sec and makes sure safebrowsing update is not happening.
+  safe_browsing_helper->CheckStatusAfterDelay(1);
+  // Loop will stop once OnCheckStatusOnIOThreadDone in safe_browsing_helper
+  // is called and status from safe_browsing_service_ is checked.
+  ui_test_utils::RunMessageLoop();
+  EXPECT_FALSE(is_update_in_progress());
+  EXPECT_TRUE(is_initial_request());
+  EXPECT_FALSE(is_update_scheduled());
+  EXPECT_TRUE(last_update().is_null());
+
+  // Verify URL.
+  const char test_url[] = "http://ianfette.org";
+  safe_browsing_helper->CheckUrl(GURL(test_url));
+  // Loop will stop once OnCheckUrlOnIOThreadDone in safe_browsing_helper
+  // is called and url check is done.
+  ui_test_utils::RunMessageLoop();
+  EXPECT_TRUE(is_url_match_in_db());
+
+  // TODO(lzheng): Add tests to launch a testing safebrowsing server
+  // and issue requests repeatedly:
+  // http://code.google.com/p/google-safe-browsing/wiki/ProtocolTesting
+}