[Android WebView] Implement WebSettings.{get|set}CacheMode

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/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 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_flags = net::LOAD_BYPASS_CACHE |

[mkosiba (inactive), 2012/11/21 12:35:15]

nit: s/all_flags/valid_flags/

[mnaganov (inactive), 2012/11/21 13:17:09]

"valid_flags" doesn't make much sense to me. Renamed to
"all_cache_control_flags" for clarity.

+      net::LOAD_VALIDATE_CACHE |
+      net::LOAD_PREFERRING_CACHE |
+      net::LOAD_ONLY_FROM_CACHE;
+  DCHECK((flag & all_flags) == flag);
+  int load_flags = request->load_flags();
+  load_flags &= ~all_flags;
+  load_flags |= flag;
+  request->set_load_flags(load_flags);
+}
+
 void SetOnlyAllowLoadFromCache(
     net::URLRequest* request) {
   int load_flags = request->load_flags();
   load_flags &= ~(net::LOAD_BYPASS_CACHE &
                   net::LOAD_VALIDATE_CACHE &
                   net::LOAD_PREFERRING_CACHE);
   load_flags |= net::LOAD_ONLY_FROM_CACHE;
   request->set_load_flags(load_flags);
 }
 
-// May cancel this resource request based on result of Java callbacks.
-class MaybeCancelResourceThrottle : public content::ResourceThrottle {
+// Enqueries certain WebSettings values, sets up the resource request
+// accordingly.  May cancel the request.
+class ApplyWebSettingsResourceThrottle : public content::ResourceThrottle {

[mkosiba (inactive), 2012/11/21 12:35:15]

might as well call this IoThreadClientThrottle to match Ben's next change

[mnaganov (inactive), 2012/11/21 13:17:09]

OK, renamed and updated the comment. But this will not save you from merge
conflicts!

  public:
-  MaybeCancelResourceThrottle(int child_id,
-                              int route_id,
-                              net::URLRequest* request)
+  ApplyWebSettingsResourceThrottle(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;
 
   scoped_ptr<AwContentsIoThreadClient> GetIoThreadClient() {
     return AwContentsIoThreadClient::FromID(child_id_, route_id_);
   }
 
  private:
   int child_id_;
   int route_id_;
   net::URLRequest* request_;
 };
 
-void MaybeCancelResourceThrottle::WillStartRequest(bool* defer) {
+void ApplyWebSettingsResourceThrottle::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()) {
     controller()->CancelWithError(net::ERR_ACCESS_DENIED);
     return;
@@ skipping 17 matching lines @@
       controller()->CancelWithError(net::ERR_ACCESS_DENIED);
       return;
     }
   }
 
   if (GetIoThreadClient()->ShouldBlockNetworkLoads()) {
     if (request_->url().SchemeIs(chrome::kFtpScheme)) {
       controller()->CancelWithError(net::ERR_ACCESS_DENIED);
       return;
     }
-    SetOnlyAllowLoadFromCache(request_);
+    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;
+    }
   }
 }
 
 }  // namespace
 
 namespace android_webview {
 
 // static
 void AwResourceDispatcherHostDelegate::ResourceDispatcherHostCreated() {
   content::ResourceDispatcherHost::Get()->SetDelegate(
@@ skipping 10 matching lines @@
 void AwResourceDispatcherHostDelegate::RequestBeginning(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     appcache::AppCacheService* appcache_service,
     ResourceType::Type resource_type,
     int child_id,
     int route_id,
     bool is_continuation_of_transferred_request,
     ScopedVector<content::ResourceThrottle>* throttles) {
 
-  throttles->push_back(new MaybeCancelResourceThrottle(
+  throttles->push_back(new ApplyWebSettingsResourceThrottle(
       child_id, route_id, request));
 
   bool allow_intercepting =
       // We ignore POST requests because of BUG=155250.
       request->method() != "POST" &&
       // We allow intercepting navigations within subframes, but only if the
       // scheme other than http or https. This is because the embedder
       // can't distinguish main frame and subframe callbacks (which could lead
       // to broken content if the embedder decides to not ignore the main frame
       // navigation, but ignores the subframe navigation).
@@ skipping 26 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;
 }
 
 }