<webview> Implement clear http cache API.

extensions/browser/api/guest_view/web_view/web_view_internal_api.cc

 // Copyright 2014 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 "extensions/browser/api/guest_view/web_view/web_view_internal_api.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
-#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/stop_find_action.h"
 #include "content/public/common/url_fetcher.h"
+#include "extensions/browser/guest_view/web_view/web_view_constants.h"
 #include "extensions/common/api/web_view_internal.h"
 #include "extensions/common/error_utils.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "third_party/WebKit/public/web/WebFindOptions.h"
 
 using content::WebContents;
 using extensions::core_api::web_view_internal::SetPermission::Params;
 using extensions::core_api::extension_types::InjectDetails;
-namespace webview = extensions::core_api::web_view_internal;
+namespace web_view_internal = extensions::core_api::web_view_internal;
 
 namespace {
 
 const char kAppCacheKey[] = "appcache";
+const char kCacheKey[] = "cache";
 const char kCookiesKey[] = "cookies";
 const char kFileSystemsKey[] = "fileSystems";
 const char kIndexedDBKey[] = "indexedDB";
 const char kLocalStorageKey[] = "localStorage";
 const char kWebSQLKey[] = "webSQL";
 const char kSinceKey[] = "since";
 const char kLoadFileError[] = "Failed to load file: \"*\". ";
 
-int MaskForKey(const char* key) {
+uint32 MaskForKey(const char* key) {
   if (strcmp(key, kAppCacheKey) == 0)
-    return content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_APPCACHE;
+  if (strcmp(key, kCacheKey) == 0)
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_CACHE;
   if (strcmp(key, kCookiesKey) == 0)
-    return content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_COOKIES;
   if (strcmp(key, kFileSystemsKey) == 0)
-    return content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_FILE_SYSTEMS;
   if (strcmp(key, kIndexedDBKey) == 0)
-    return content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_INDEXEDDB;
   if (strcmp(key, kLocalStorageKey) == 0)
-    return content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_LOCAL_STORAGE;
   if (strcmp(key, kWebSQLKey) == 0)
-    return content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
+    return webview::WEB_VIEW_REMOVE_DATA_MASK_WEBSQL;
   return 0;
 }
 
 }  // namespace
 
 namespace extensions {
 
 // WebUIURLFetcher downloads the content of a file by giving its |url| on WebUI.
 // Each WebUIURLFetcher is associated with a given |render_process_id,
 // render_view_id| pair.
@@ skipping 44 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &instance_id));
   WebViewGuest* guest = WebViewGuest::From(
       render_view_host()->GetProcess()->GetID(), instance_id);
   if (!guest)
     return false;
 
   return RunAsyncSafe(guest);
 }
 
 bool WebViewInternalNavigateFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::Navigate::Params> params(
-      webview::Navigate::Params::Create(*args_));
+  scoped_ptr<web_view_internal::Navigate::Params> params(
+      web_view_internal::Navigate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   std::string src = params->src;
   guest->NavigateGuest(src, true /* force_navigation */);
   return true;
 }
 
 WebViewInternalExecuteCodeFunction::WebViewInternalExecuteCodeFunction()
     : guest_instance_id_(0), guest_src_(GURL::EmptyGURL()) {
 }
 
@@ skipping 124 matching lines @@
   return true;
 }
 
 WebViewInternalSetNameFunction::WebViewInternalSetNameFunction() {
 }
 
 WebViewInternalSetNameFunction::~WebViewInternalSetNameFunction() {
 }
 
 bool WebViewInternalSetNameFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::SetName::Params> params(
-      webview::SetName::Params::Create(*args_));
+  scoped_ptr<web_view_internal::SetName::Params> params(
+      web_view_internal::SetName::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetName(params->frame_name);
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetAllowTransparencyFunction::
 WebViewInternalSetAllowTransparencyFunction() {
 }
 
 WebViewInternalSetAllowTransparencyFunction::
 ~WebViewInternalSetAllowTransparencyFunction() {
 }
 
 bool WebViewInternalSetAllowTransparencyFunction::RunAsyncSafe(
     WebViewGuest* guest) {
-  scoped_ptr<webview::SetAllowTransparency::Params> params(
-      webview::SetAllowTransparency::Params::Create(*args_));
+  scoped_ptr<web_view_internal::SetAllowTransparency::Params> params(
+      web_view_internal::SetAllowTransparency::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetAllowTransparency(params->allow);
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetAllowScalingFunction::
     WebViewInternalSetAllowScalingFunction() {
 }
 
 WebViewInternalSetAllowScalingFunction::
     ~WebViewInternalSetAllowScalingFunction() {
 }
 
 bool WebViewInternalSetAllowScalingFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::SetAllowScaling::Params> params(
-      webview::SetAllowScaling::Params::Create(*args_));
+  scoped_ptr<web_view_internal::SetAllowScaling::Params> params(
+      web_view_internal::SetAllowScaling::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetAllowScaling(params->allow);
   SendResponse(true);
   return true;
 }
 
 WebViewInternalSetZoomFunction::WebViewInternalSetZoomFunction() {
 }
 
 WebViewInternalSetZoomFunction::~WebViewInternalSetZoomFunction() {
 }
 
 bool WebViewInternalSetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::SetZoom::Params> params(
-      webview::SetZoom::Params::Create(*args_));
+  scoped_ptr<web_view_internal::SetZoom::Params> params(
+      web_view_internal::SetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   guest->SetZoom(params->zoom_factor);
 
   SendResponse(true);
   return true;
 }
 
 WebViewInternalGetZoomFunction::WebViewInternalGetZoomFunction() {
 }
 
 WebViewInternalGetZoomFunction::~WebViewInternalGetZoomFunction() {
 }
 
 bool WebViewInternalGetZoomFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::GetZoom::Params> params(
-      webview::GetZoom::Params::Create(*args_));
+  scoped_ptr<web_view_internal::GetZoom::Params> params(
+      web_view_internal::GetZoom::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   double zoom_factor = guest->zoom();
   SetResult(new base::FundamentalValue(zoom_factor));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalFindFunction::WebViewInternalFindFunction() {
 }
 
 WebViewInternalFindFunction::~WebViewInternalFindFunction() {
 }
 
 bool WebViewInternalFindFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::Find::Params> params(
-      webview::Find::Params::Create(*args_));
+  scoped_ptr<web_view_internal::Find::Params> params(
+      web_view_internal::Find::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Convert the std::string search_text to string16.
   base::string16 search_text;
   base::UTF8ToUTF16(
       params->search_text.c_str(), params->search_text.length(), &search_text);
 
   // Set the find options to their default values.
   blink::WebFindOptions options;
   if (params->options) {
     options.forward =
         params->options->backward ? !*params->options->backward : true;
     options.matchCase =
         params->options->match_case ? *params->options->match_case : false;
   }
 
   guest->StartFindInternal(search_text, options, this);
   return true;
 }
 
 WebViewInternalStopFindingFunction::WebViewInternalStopFindingFunction() {
 }
 
 WebViewInternalStopFindingFunction::~WebViewInternalStopFindingFunction() {
 }
 
 bool WebViewInternalStopFindingFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::StopFinding::Params> params(
-      webview::StopFinding::Params::Create(*args_));
+  scoped_ptr<web_view_internal::StopFinding::Params> params(
+      web_view_internal::StopFinding::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Set the StopFindAction.
   content::StopFindAction action;
   switch (params->action) {
-    case webview::StopFinding::Params::ACTION_CLEAR:
+    case web_view_internal::StopFinding::Params::ACTION_CLEAR:
       action = content::STOP_FIND_ACTION_CLEAR_SELECTION;
       break;
-    case webview::StopFinding::Params::ACTION_KEEP:
+    case web_view_internal::StopFinding::Params::ACTION_KEEP:
       action = content::STOP_FIND_ACTION_KEEP_SELECTION;
       break;
-    case webview::StopFinding::Params::ACTION_ACTIVATE:
+    case web_view_internal::StopFinding::Params::ACTION_ACTIVATE:
       action = content::STOP_FIND_ACTION_ACTIVATE_SELECTION;
       break;
     default:
       action = content::STOP_FIND_ACTION_KEEP_SELECTION;
   }
 
   guest->StopFindingInternal(action);
   return true;
 }
 
 WebViewInternalLoadDataWithBaseUrlFunction::
     WebViewInternalLoadDataWithBaseUrlFunction() {
 }
 
 WebViewInternalLoadDataWithBaseUrlFunction::
     ~WebViewInternalLoadDataWithBaseUrlFunction() {
 }
 
 bool WebViewInternalLoadDataWithBaseUrlFunction::RunAsyncSafe(
     WebViewGuest* guest) {
-  scoped_ptr<webview::LoadDataWithBaseUrl::Params> params(
-      webview::LoadDataWithBaseUrl::Params::Create(*args_));
+  scoped_ptr<web_view_internal::LoadDataWithBaseUrl::Params> params(
+      web_view_internal::LoadDataWithBaseUrl::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // If a virtual URL was provided, use it. Otherwise, the user will be shown
   // the data URL.
   std::string virtual_url =
       params->virtual_url ? *params->virtual_url : params->data_url;
 
   bool successful = guest->LoadDataWithBaseURL(
       params->data_url, params->base_url, virtual_url, &error_);
   SendResponse(successful);
   return successful;
 }
 
 WebViewInternalGoFunction::WebViewInternalGoFunction() {
 }
 
 WebViewInternalGoFunction::~WebViewInternalGoFunction() {
 }
 
 bool WebViewInternalGoFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::Go::Params> params(webview::Go::Params::Create(*args_));
+  scoped_ptr<web_view_internal::Go::Params> params(
+      web_view_internal::Go::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool successful = guest->Go(params->relative_index);
   SetResult(new base::FundamentalValue(successful));
   SendResponse(true);
   return true;
 }
 
 WebViewInternalReloadFunction::WebViewInternalReloadFunction() {
 }
 
 WebViewInternalReloadFunction::~WebViewInternalReloadFunction() {
 }
 
 bool WebViewInternalReloadFunction::RunAsyncSafe(WebViewGuest* guest) {
   guest->Reload();
   return true;
 }
 
 WebViewInternalSetPermissionFunction::WebViewInternalSetPermissionFunction() {
 }
 
 WebViewInternalSetPermissionFunction::~WebViewInternalSetPermissionFunction() {
 }
 
 bool WebViewInternalSetPermissionFunction::RunAsyncSafe(WebViewGuest* guest) {
-  scoped_ptr<webview::SetPermission::Params> params(
-      webview::SetPermission::Params::Create(*args_));
+  scoped_ptr<web_view_internal::SetPermission::Params> params(
+      web_view_internal::SetPermission::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   WebViewPermissionHelper::PermissionResponseAction action =
       WebViewPermissionHelper::DEFAULT;
   switch (params->action) {
     case Params::ACTION_ALLOW:
       action = WebViewPermissionHelper::ALLOW;
       break;
     case Params::ACTION_DENY:
       action = WebViewPermissionHelper::DENY;
@@ skipping 27 matching lines @@
 WebViewInternalOverrideUserAgentFunction::
     WebViewInternalOverrideUserAgentFunction() {
 }
 
 WebViewInternalOverrideUserAgentFunction::
     ~WebViewInternalOverrideUserAgentFunction() {
 }
 
 bool WebViewInternalOverrideUserAgentFunction::RunAsyncSafe(
     WebViewGuest* guest) {
-  scoped_ptr<webview::OverrideUserAgent::Params> params(
-      webview::OverrideUserAgent::Params::Create(*args_));
+  scoped_ptr<web_view_internal::OverrideUserAgent::Params> params(
+      web_view_internal::OverrideUserAgent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   guest->SetUserAgentOverride(params->user_agent_override);
   return true;
 }
 
 WebViewInternalStopFunction::WebViewInternalStopFunction() {
 }
 
 WebViewInternalStopFunction::~WebViewInternalStopFunction() {
@@ skipping 91 matching lines @@
   // Will finish asynchronously.
   return true;
 }
 
 void WebViewInternalClearDataFunction::ClearDataDone() {
   Release();  // Balanced in RunAsync().
   SendResponse(true);
 }
 
 }  // namespace extensions