Implement a ResourceThrottle for URL overriding in Chrome on Android.

chrome/browser/renderer_host/intercept_navigation_resource_throttle.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.
+
+#include "chrome/browser/renderer_host/intercept_navigation_resource_throttle.h"
+
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/resource_request_info.h"
+#include "content/public/browser/resource_controller.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_delegate.h"
+#include "content/public/common/referrer.h"
+#include "net/url_request/url_request.h"
+
+using content::BrowserThread;
+using content::ChildProcessSecurityPolicy;
+using content::Referrer;
+using content::RenderViewHost;
+using content::ResourceRequestInfo;
+using content::WebContents;
+using content::WebContentsDelegate;
+
+namespace {
+
+void CheckShouldIgnoreNavigationOnUIThread(

[darin (slow to review), 2012/06/15 19:52:55]

nit: CheckIfShouldIgnoreNavigationOnUIThread

[mkosiba (inactive), 2012/06/18 10:47:06]

Done.

+    int render_process_id,
+    int render_view_id,
+    const GURL& url,
+    const Referrer& referrer,
+    bool is_content_initiated,
+    InterceptNavigationResourceThrottle::CheckOnUIThreadCallback
+        should_ignore_callback,
+    base::Callback<void(bool)> callback) {
+
+  RenderViewHost* rvh =
+      RenderViewHost::FromID(render_process_id, render_view_id);
+  WebContents* web_contents =
+      rvh ? WebContents::FromRenderViewHost(rvh) : NULL;
+
+  GURL validated_url(url);
+  RenderViewHost::FilterURL(
+      rvh->GetProcess()->GetID(),
+      false,
+      &validated_url);
+
+  bool should_ignore_navigation = false;
+  if (web_contents) {
+    should_ignore_navigation = should_ignore_callback.Run(
+            web_contents, validated_url, referrer, is_content_initiated);

[darin (slow to review), 2012/06/15 19:52:55]

nit: indentation

[mkosiba (inactive), 2012/06/18 10:47:06]

Done.

+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(callback, should_ignore_navigation));
+}
+
+} // namespace
+
+InterceptNavigationResourceThrottle::InterceptNavigationResourceThrottle(
+    net::URLRequest* request,
+    CheckOnUIThreadCallback should_ignore_callback)
+    : request_(request),
+      should_ignore_callback_(should_ignore_callback),
+      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {

[darin (slow to review), 2012/06/15 19:52:55]

nit: maybe just extend from SupportsWeakPtr so you can avoid this line?

[mkosiba (inactive), 2012/06/18 10:47:06]

Extending from SupportsWeakPtr makes the WeakPtr support public. Since the
WeakPtrFactory is an implementation detail I'd like to keep it hidden.

+}
+
+InterceptNavigationResourceThrottle::~InterceptNavigationResourceThrottle() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+}
+
+void InterceptNavigationResourceThrottle::WillStartRequest(bool* defer) {
+  *defer = ShouldDeferRequestForURL(request_->url());
+}
+
+void InterceptNavigationResourceThrottle::WillRedirectRequest(
+    const GURL& new_url,
+    bool* defer) {
+  *defer = ShouldDeferRequestForURL(new_url);
+}
+
+bool InterceptNavigationResourceThrottle::ShouldDeferRequestForURL(

[darin (slow to review), 2012/06/15 19:52:55]

it seems like this function is not named that well.  it does a lot more than
just determine if the request should be deferred.  in fact, it is almost always
going to defer the request.  it'll only defer in really broken cases, where the
request has unknown info or no associated renderview.  that doesn't happen
unless the system is broken.

maybe CheckIfShouldIgnoreNavigation?

[mkosiba (inactive), 2012/06/18 10:47:06]

Done.

+    const GURL& url) {
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
+  if (!info)
+    return false;
+
+  int render_process_id, render_view_id;
+  if (!info->GetAssociatedRenderView(&render_process_id, &render_view_id)) {
+    return false;
+  }
+
+  // This class should only be instantiated for top level frame requests.
+  DCHECK(info->IsMainFrame());
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &CheckShouldIgnoreNavigationOnUIThread,
+          render_process_id,
+          render_view_id,
+          url,
+          Referrer(GURL(request_->referrer()), info->GetReferrerPolicy()),
+          info->HasUserGesture(),
+          should_ignore_callback_,
+          base::Bind(
+              &InterceptNavigationResourceThrottle::OnResultObtained,
+              weak_ptr_factory_.GetWeakPtr())));
+
+  // Defer request while we wait for the UI thread to check if the navigation
+  // should be ignored.
+  return true;
+}
+
+void InterceptNavigationResourceThrottle::OnResultObtained(
+    bool should_ignore_navigation) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (should_ignore_navigation) {
+    // TODO(mkosiba): Cancel() results in a CANCELLED status but what we really

[darin (slow to review), 2012/06/15 19:52:55]

I've been thinking of providing an alternate Cancel(int error_code) that would
help here.

[mkosiba (inactive), 2012/06/18 10:47:06]

I don't think that'd help unless you also include a status code. I need to set a
status of (HANDLED_EXTERNALLY, OK), rather than (CANCELED, error_code).

I'd really like to work on getting the right way of communicating the
HANDLED_EXTERNALLY status in a followup CL if that's OK with you.

+    // want is a HANDLED_EXTERNALLY status.
+    controller()->Cancel();
+  } else {
+    controller()->Resume();
+  }
+}