[Android WebView] AwContentsClient.shouldCreate window callback part 2.

android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.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 "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
 
 #include "android_webview/browser/aw_login_delegate.h"
-#include "android_webview/browser/aw_contents_io_thread_client.h"
 #include "android_webview/common/url_constants.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "content/components/navigation_interception/intercept_navigation_delegate.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/resource_dispatcher_host_login_delegate.h"
-#include "content/public/browser/resource_throttle.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request.h"
 
+using android_webview::AwContentsIoThreadClient;
+using content::BrowserThread;
 using content::InterceptNavigationDelegate;
 
 namespace {
 
-using android_webview::AwContentsIoThreadClient;
-
 base::LazyInstance<android_webview::AwResourceDispatcherHostDelegate>
     g_webview_resource_dispatcher_host_delegate = LAZY_INSTANCE_INITIALIZER;
 
 void SetCacheControlFlag(
     net::URLRequest* request, int flag) {
   const int all_cache_control_flags = net::LOAD_BYPASS_CACHE |
       net::LOAD_VALIDATE_CACHE |
       net::LOAD_PREFERRING_CACHE |
       net::LOAD_ONLY_FROM_CACHE;
   DCHECK((flag & all_cache_control_flags) == flag);
   int load_flags = request->load_flags();
   load_flags &= ~all_cache_control_flags;
   load_flags |= flag;
   request->set_load_flags(load_flags);
 }
 
-// Calls through the IoThreadClient to check the embedders settings to determine
-// if the request should be cancelled.
-class IoThreadClientThrottle : public content::ResourceThrottle {
- public:
-  IoThreadClientThrottle(int child_id,
-                         int route_id,
-                         net::URLRequest* request)
-      : child_id_(child_id),
-        route_id_(route_id),
-        request_(request) { }
-  virtual void WillStartRequest(bool* defer) OVERRIDE;
+}  // namespace
 
-  scoped_ptr<AwContentsIoThreadClient> GetIoThreadClient() {
-    return AwContentsIoThreadClient::FromID(child_id_, route_id_);
-  }
+namespace android_webview {
 
- private:
-  int child_id_;
-  int route_id_;
-  net::URLRequest* request_;
-};
+AwResourceDispatcherHostDelegate::PendingThrottleMap*
+    AwResourceDispatcherHostDelegate::pending_throttles_ = 0;
+
+IoThreadClientThrottle::IoThreadClientThrottle(int child_id,
+                                               int route_id,
+                                               net::URLRequest* request)
+    : child_id_(child_id),
+      route_id_(route_id),
+      request_(request) { }
+
+IoThreadClientThrottle::~IoThreadClientThrottle() {

[joth, 2012/11/29 21:02:33]

It maybe best to do the map.erase(this) call from here. That will ensure the map
is not left with stale pointer however this thing gets deleted.
(although, need to take care about thread safety. I think that map should only
be touched on IO thread, so should be fine. DCHECKs will help :)

[benm (inactive), 2012/11/30 12:54:18]

Done.

+}
 
 void IoThreadClientThrottle::WillStartRequest(bool* defer) {
-  // If there is no IO thread client set at this point, use a
-  // restrictive policy. This can happen for blocked popup
-  // windows for example.
-  // TODO(benm): Revert this to a DCHECK when the we support
-  // pop up windows being created in the WebView, as at that
-  // time we should always have an IoThreadClient at this
-  // point (i.e., the one associated with the new popup).
-  if (!GetIoThreadClient()) {
+  if (!MaybeDeferRequest(defer)) {
+    MaybeBlockRequest();
+  }
+}
+
+void IoThreadClientThrottle::WillRedirectRequest(const GURL& new_url,
+                                                 bool* defer) {
+  WillStartRequest(defer);
+}
+
+bool IoThreadClientThrottle::MaybeDeferRequest(bool* defer) {
+  scoped_ptr<AwContentsIoThreadClient> io_client =
+      AwContentsIoThreadClient::FromID(child_id_, route_id_);
+  *defer = false;
+  if (!io_client.get()) {
+    *defer = true;
+    AwResourceDispatcherHostDelegate::AddPendingThrottle(
+        child_id_, route_id_, this);
+  }
+  return *defer;
+}
+
+void IoThreadClientThrottle::OnIoThreadClientReady(int new_child_id,
+                                                   int new_route_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!MaybeBlockRequest()) {
+    controller()->Resume();
+  }
+}
+
+bool IoThreadClientThrottle::MaybeBlockRequest() {
+  if (ShouldBlockRequest()) {
     controller()->CancelWithError(net::ERR_ACCESS_DENIED);
-    return;
+    return true;
   }
+  return false;
+}
+
+bool IoThreadClientThrottle::ShouldBlockRequest() {
+  scoped_ptr<AwContentsIoThreadClient> io_client =
+      AwContentsIoThreadClient::FromID(child_id_, route_id_);
+  DCHECK(io_client.get());
 
   // Part of implementation of WebSettings.allowContentAccess.
   if (request_->url().SchemeIs(android_webview::kContentScheme) &&
-      GetIoThreadClient()->ShouldBlockContentUrls()) {
-    controller()->CancelWithError(net::ERR_ACCESS_DENIED);
-    return;
+      io_client->ShouldBlockContentUrls()) {
+    return true;
   }
 
   // Part of implementation of WebSettings.allowFileAccess.
   if (request_->url().SchemeIsFile() &&
-      GetIoThreadClient()->ShouldBlockFileUrls()) {
+      io_client->ShouldBlockFileUrls()) {
     const GURL& url = request_->url();
     if (!url.has_path() ||
         // Application's assets and resources are always available.
         (url.path().find(android_webview::kAndroidResourcePath) != 0 &&
          url.path().find(android_webview::kAndroidAssetPath) != 0)) {
-      controller()->CancelWithError(net::ERR_ACCESS_DENIED);
-      return;
+      return true;
     }
   }
 
-  if (GetIoThreadClient()->ShouldBlockNetworkLoads()) {
+  if (io_client->ShouldBlockNetworkLoads()) {
     if (request_->url().SchemeIs(chrome::kFtpScheme)) {
-      controller()->CancelWithError(net::ERR_ACCESS_DENIED);
-      return;
+      return true;
     }
     SetCacheControlFlag(request_, net::LOAD_ONLY_FROM_CACHE);
   } else {
     AwContentsIoThreadClient::CacheMode cache_mode =
         GetIoThreadClient()->GetCacheMode();
     switch(cache_mode) {
       case AwContentsIoThreadClient::LOAD_CACHE_ELSE_NETWORK:
         SetCacheControlFlag(request_, net::LOAD_PREFERRING_CACHE);
         break;
       case AwContentsIoThreadClient::LOAD_NO_CACHE:
         SetCacheControlFlag(request_, net::LOAD_BYPASS_CACHE);
         break;
       case AwContentsIoThreadClient::LOAD_CACHE_ONLY:
         SetCacheControlFlag(request_, net::LOAD_ONLY_FROM_CACHE);
         break;
       default:
         break;
     }
   }
+  return false;
 }
 
-}  // namespace
-
-namespace android_webview {
+scoped_ptr<AwContentsIoThreadClient>
+    IoThreadClientThrottle::GetIoThreadClient() {
+  return AwContentsIoThreadClient::FromID(child_id_, route_id_);
+}
 
 // static
 void AwResourceDispatcherHostDelegate::ResourceDispatcherHostCreated() {
   content::ResourceDispatcherHost::Get()->SetDelegate(
       &g_webview_resource_dispatcher_host_delegate.Get());
 }
 
 AwResourceDispatcherHostDelegate::AwResourceDispatcherHostDelegate()
     : content::ResourceDispatcherHostDelegate() {
 }
@@ skipping 50 matching lines @@
 
 bool AwResourceDispatcherHostDelegate::HandleExternalProtocol(const GURL& url,
                                                               int child_id,
                                                               int route_id) {
   // The AwURLRequestJobFactory implementation should ensure this method never
   // gets called.
   NOTREACHED();
   return false;
 }
 
+// static
+void AwResourceDispatcherHostDelegate::OnIoThreadClientReady(
+    int new_child_id,
+    int new_route_id) {
+  if (!pending_throttles_)
+    return;
+
+  PendingThrottleMap::iterator it = pending_throttles_->find(
+      ChildRouteIDPair(new_child_id, new_route_id));
+
+  if (it != pending_throttles_->end()) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+        base::Bind(&IoThreadClientThrottle::OnIoThreadClientReady,
+                   base::Unretained(it->second), new_child_id, new_route_id));
+    pending_throttles_->erase(it);
+  }
 }
+
+// static
+void AwResourceDispatcherHostDelegate::AddPendingThrottle(
+    int child_id,
+    int route_id,
+    IoThreadClientThrottle* pending_throttle) {
+  if (!pending_throttles_) {
+    pending_throttles_ = new PendingThrottleMap();
+  }
+
+  pending_throttles_->insert(

[joth, 2012/11/29 21:02:33]

does this get run on IO thread? we're searching and erasing on UI thread above.

hmm. I think we can do all access to it on IO thread, if we just have
OnIoThreadClientReady call itself straight back on the IO thread.

[benm (inactive), 2012/11/30 12:54:18]

Done.

+      std::pair<ChildRouteIDPair, IoThreadClientThrottle*>(
+          ChildRouteIDPair(child_id, route_id), pending_throttle));
+}
+
+}  // namespace android_webview