[subresource_filter] SB throttle can send multiple speculative requests.

components/subresource_filter/content/browser/subresource_filter_safe_browsing_client.cc

Index: components/subresource_filter/content/browser/subresource_filter_safe_browsing_client.cc
diff --git a/components/subresource_filter/content/browser/subresource_filter_safe_browsing_client.cc b/components/subresource_filter/content/browser/subresource_filter_safe_browsing_client.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6dd5b2d412bda29c234d14d911787cdb1b13f9f5
--- /dev/null
+++ b/components/subresource_filter/content/browser/subresource_filter_safe_browsing_client.cc
@@ -0,0 +1,124 @@
+// Copyright (c) 2017 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 "components/subresource_filter/content/browser/subresource_filter_safe_browsing_client.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/single_thread_task_runner.h"
+#include "base/timer/timer.h"
+#include "components/safe_browsing_db/util.h"
+#include "components/subresource_filter/content/browser/subresource_filter_safe_browsing_activation_throttle.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace subresource_filter {
+
+// Maximum time in milliseconds to wait for the Safe Browsing service to
+// verify a URL. After this amount of time the outstanding check will be
+// aborted, and the URL will be treated as if it didn't belong to the
+// Subresource Filter only list.
+constexpr base::TimeDelta
+    SubresourceFilterSafeBrowsingClientRequest::kCheckURLTimeout =
+        base::TimeDelta::FromSeconds(5);
+
+SubresourceFilterSafeBrowsingClient::SubresourceFilterSafeBrowsingClient(
+    std::unique_ptr<base::Timer> timer,
+    scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager,
+    const base::WeakPtr<SubresourceFilterSafeBrowsingActivationThrottle>&
+        throttle,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
+    : timer_(std::move(timer)),
+      database_manager_(std::move(database_manager)),
+      throttle_(throttle),
+      ui_task_runner_(io_task_runner) {}
+
+SubresourceFilterSafeBrowsingClient::~SubresourceFilterSafeBrowsingClient() {}
+
+void SubresourceFilterSafeBrowsingClient::CheckUrlOnIO(const GURL& url,
+                                                       int request_id) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK(!url.is_empty());
+
+  // Will cancel the previous request, and it should never complete. This
+  // ensures that requests are notified in order.
+  current_request_ =
+      base::MakeUnique<SubresourceFilterSafeBrowsingClientRequest>(
+          timer_.get(), url, request_id, database_manager_, this);
+  current_request_->Start();
+}
+
+void SubresourceFilterSafeBrowsingClient::OnCheckBrowseUrlResult(
+    SubresourceFilterSafeBrowsingClientRequest* request,
+    safe_browsing::SBThreatType threat_type,
+    const safe_browsing::ThreatMetadata& metadata) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK_EQ(request->request_id(), current_request_->request_id());
+  ui_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&SubresourceFilterSafeBrowsingActivationThrottle::
+                                OnCheckUrlResultOnUI,
+                            throttle_, request->url(), request->request_id(),
+                            threat_type, metadata.threat_pattern_type));
+
+  current_request_.reset();
+}
+
+SubresourceFilterSafeBrowsingClientRequest::
+    SubresourceFilterSafeBrowsingClientRequest(
+        base::Timer* timer,
+        const GURL& url,
+        int request_id,
+        scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager>
+            database_manager,
+        SubresourceFilterSafeBrowsingClient* client)
+    : url_(url),
+      request_id_(request_id),
+      database_manager_(std::move(database_manager)),
+      client_(client),
+      timer_(timer) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+}
+
+void SubresourceFilterSafeBrowsingClientRequest::Start() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  if (database_manager_->CheckUrlForSubresourceFilter(url_, this)) {
+    OnCheckBrowseUrlResult(url_, safe_browsing::SB_THREAT_TYPE_SAFE,
+                           safe_browsing::ThreatMetadata());
+    return;
+  }
+  timer_->Start(
+      FROM_HERE, kCheckURLTimeout,
+      base::Bind(&SubresourceFilterSafeBrowsingClientRequest::OnCheckUrlTimeout,
+                 base::Unretained(this)));
+}
+
+SubresourceFilterSafeBrowsingClientRequest::
+    ~SubresourceFilterSafeBrowsingClientRequest() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  database_manager_->CancelCheck(this);
+  is_cancelled_ = true;
+  timer_->Stop();
+}
+
+void SubresourceFilterSafeBrowsingClientRequest::OnCheckBrowseUrlResult(
+    const GURL& url,
+    safe_browsing::SBThreatType threat_type,
+    const safe_browsing::ThreatMetadata& metadata) {
+  DCHECK(!is_cancelled_);
+  DCHECK_EQ(url_, url);
+  timer_->Stop();  // Cancel the timeout timer.
+  client_->OnCheckBrowseUrlResult(this, threat_type, metadata);
+}
+
+void SubresourceFilterSafeBrowsingClientRequest::OnCheckUrlTimeout() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  database_manager_->CancelCheck(this);
+
+  OnCheckBrowseUrlResult(url_, safe_browsing::SB_THREAT_TYPE_SAFE,
+                         safe_browsing::ThreatMetadata());
+  is_cancelled_ = true;
+}
+
+}  // namespace subresource_filter