Refactor PluginPermissionHelper as WebViewPermissionHelper

chrome/browser/guest_view/web_view/web_view_guest.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 "chrome/browser/guest_view/web_view/web_view_guest.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/api/web_view/web_view_internal_api.h"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/extensions/script_executor.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
-#include "chrome/browser/geolocation/geolocation_permission_context.h"
-#include "chrome/browser/geolocation/geolocation_permission_context_factory.h"
 #include "chrome/browser/guest_view/guest_view_constants.h"
 #include "chrome/browser/guest_view/guest_view_manager.h"
 #include "chrome/browser/guest_view/web_view/web_view_constants.h"
+#include "chrome/browser/guest_view/web_view/web_view_permission_helper.h"
 #include "chrome/browser/guest_view/web_view/web_view_permission_types.h"
 #include "chrome/browser/guest_view/web_view/web_view_renderer_state.h"
 #include "chrome/browser/renderer_context_menu/context_menu_delegate.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
 #include "chrome/browser/ui/pdf/pdf_tab_helper.h"
 #include "chrome/browser/ui/zoom/zoom_controller.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
@@ skipping 25 matching lines @@
 
 #if defined(ENABLE_PRINTING)
 #if defined(ENABLE_FULL_PRINTING)
 #include "chrome/browser/printing/print_preview_message_handler.h"
 #include "chrome/browser/printing/print_view_manager.h"
 #else
 #include "chrome/browser/printing/print_view_manager_basic.h"
 #endif  // defined(ENABLE_FULL_PRINTING)
 #endif  // defined(ENABLE_PRINTING)
 
-#if defined(ENABLE_PLUGINS) && !defined(OS_ANDROID)
-#include "chrome/browser/guest_view/web_view/plugin_permission_helper.h"
-#endif
-
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #endif
 
 using base::UserMetricsAction;
 using content::RenderFrameHost;
 using content::ResourceType;
 using content::WebContents;
 
 namespace {
@@ skipping 32 matching lines @@
       return "killed";
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
       return "crashed";
     case base::TERMINATION_STATUS_MAX_ENUM:
       break;
   }
   NOTREACHED() << "Unknown Termination Status.";
   return "unknown";
 }
 
-static std::string PermissionTypeToString(WebViewPermissionType type) {
-  switch (type) {
-    case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
-      return webview::kPermissionTypeDownload;
-    case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM:
-      return webview::kPermissionTypeFileSystem;
-    case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
-      return webview::kPermissionTypeGeolocation;
-    case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
-      return webview::kPermissionTypeDialog;
-    case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
-      return webview::kPermissionTypeLoadPlugin;
-    case WEB_VIEW_PERMISSION_TYPE_MEDIA:
-      return webview::kPermissionTypeMedia;
-    case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
-      return webview::kPermissionTypeNewWindow;
-    case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
-      return webview::kPermissionTypePointerLock;
-    default:
-      NOTREACHED();
-      return std::string();
-  }
-}
-
 std::string GetStoragePartitionIdFromSiteURL(const GURL& site_url) {
   const std::string& partition_id = site_url.query();
   bool persist_storage = site_url.path().find("persist") != std::string::npos;
   return (persist_storage ? webview::kPersistPrefix : "") + partition_id;
 }
 
 void RemoveWebViewEventListenersOnIOThread(
     void* profile,
     const std::string& extension_id,
     int embedder_process_id,
     int view_instance_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   ExtensionWebRequestEventRouter::GetInstance()->RemoveWebViewEventListeners(
       profile,
       extension_id,
       embedder_process_id,
       view_instance_id);
 }
 
-void AttachWebViewHelpers(WebContents* contents) {
-  // Create a zoom controller for the guest contents give it access to
-  // GetZoomLevel() and and SetZoomLevel() in WebViewGuest.
-  // TODO(wjmaclean) This currently uses the same HostZoomMap as the browser
-  // context, but we eventually want to isolate the guest contents from zoom
-  // changes outside the guest (e.g. in the main browser), so we should
-  // create a separate HostZoomMap for the guest.
-  ZoomController::CreateForWebContents(contents);
-
-  FaviconTabHelper::CreateForWebContents(contents);
-  extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
-      contents);
-#if defined(ENABLE_PLUGINS) && !defined(OS_ANDROID)
-  PluginPermissionHelper::CreateForWebContents(contents);
-#endif
-#if defined(ENABLE_PRINTING)
-#if defined(ENABLE_FULL_PRINTING)
-  printing::PrintViewManager::CreateForWebContents(contents);
-  printing::PrintPreviewMessageHandler::CreateForWebContents(contents);
-#else
-  printing::PrintViewManagerBasic::CreateForWebContents(contents);
-#endif  // defined(ENABLE_FULL_PRINTING)
-#endif  // defined(ENABLE_PRINTING)
-  PDFTabHelper::CreateForWebContents(contents);
-}
-
 void ParsePartitionParam(const base::DictionaryValue& create_params,
                          std::string* storage_partition_id,
                          bool* persist_storage) {
   std::string partition_str;
   if (!create_params.GetString(webview::kStoragePartitionId, &partition_str)) {
     return;
   }
 
   // Since the "persist:" prefix is in ASCII, StartsWith will work fine on
   // UTF-8 encoded |partition_id|. If the prefix is a match, we can safely
@@ skipping 15 matching lines @@
     *persist_storage = false;
   }
 }
 
 }  // namespace
 
 WebViewGuest::WebViewGuest(content::BrowserContext* browser_context,
                            int guest_instance_id)
    :  GuestView<WebViewGuest>(browser_context, guest_instance_id),
       pending_context_menu_request_id_(0),
-      next_permission_request_id_(0),
       is_overriding_user_agent_(false),
       main_frame_id_(0),
       chromevox_injected_(false),
       current_zoom_factor_(1.0),
       find_helper_(this),
       javascript_dialog_helper_(this) {
 }
 
 // static
 bool WebViewGuest::GetGuestPartitionConfigForSite(
@@ skipping 24 matching lines @@
 // static
 int WebViewGuest::GetViewInstanceId(WebContents* contents) {
   WebViewGuest* guest = FromWebContents(contents);
   if (!guest)
     return guestview::kInstanceIDNone;
 
   return guest->view_instance_id();
 }
 
 // static
-void WebViewGuest::RecordUserInitiatedUMA(const PermissionResponseInfo& info,
-                                          bool allow) {
-  if (allow) {
-    // Note that |allow| == true means the embedder explicitly allowed the
-    // request. For some requests they might still fail. An example of such
-    // scenario would be: an embedder allows geolocation request but doesn't
-    // have geolocation access on its own.
-    switch (info.permission_type) {
-      case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionAllow.Download"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionAllow.FileSystem"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionAllow.Geolocation"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionAllow.JSDialog"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
-        content::RecordAction(
-            UserMetricsAction("WebView.Guest.PermissionAllow.PluginLoad"));
-      case WEB_VIEW_PERMISSION_TYPE_MEDIA:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionAllow.Media"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
-        content::RecordAction(
-            UserMetricsAction("BrowserPlugin.PermissionAllow.NewWindow"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionAllow.PointerLock"));
-        break;
-      default:
-        break;
-    }
-  } else {
-    switch (info.permission_type) {
-      case WEB_VIEW_PERMISSION_TYPE_DOWNLOAD:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionDeny.Download"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_FILESYSTEM:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionDeny.FileSystem"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_GEOLOCATION:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionDeny.Geolocation"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionDeny.JSDialog"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
-        content::RecordAction(
-            UserMetricsAction("WebView.Guest.PermissionDeny.PluginLoad"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_MEDIA:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionDeny.Media"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW:
-        content::RecordAction(
-            UserMetricsAction("BrowserPlugin.PermissionDeny.NewWindow"));
-        break;
-      case WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK:
-        content::RecordAction(
-            UserMetricsAction("WebView.PermissionDeny.PointerLock"));
-        break;
-      default:
-        break;
-    }
-  }
-}
-
-// static
 scoped_ptr<base::ListValue> WebViewGuest::MenuModelToValue(
     const ui::SimpleMenuModel& menu_model) {
   scoped_ptr<base::ListValue> items(new base::ListValue());
   for (int i = 0; i < menu_model.GetItemCount(); ++i) {
     base::DictionaryValue* item_value = new base::DictionaryValue();
     // TODO(lazyboy): We need to expose some kind of enum equivalent of
     // |command_id| instead of plain integers.
     item_value->SetInteger(webview::kMenuItemCommandId,
                            menu_model.GetCommandIdAt(i));
     item_value->SetString(webview::kMenuItemLabel, menu_model.GetLabelAt(i));
@@ skipping 120 matching lines @@
       chromeos::AccessibilityManager::Get();
   CHECK(accessibility_manager);
   accessibility_subscription_ = accessibility_manager->RegisterCallback(
       base::Bind(&WebViewGuest::OnAccessibilityStatusChanged,
                  base::Unretained(this)));
 #endif
 
   AttachWebViewHelpers(guest_web_contents());
 }
 
+void WebViewGuest::AttachWebViewHelpers(WebContents* contents) {
+  // Create a zoom controller for the guest contents give it access to
+  // GetZoomLevel() and and SetZoomLevel() in WebViewGuest.
+  // TODO(wjmaclean) This currently uses the same HostZoomMap as the browser
+  // context, but we eventually want to isolate the guest contents from zoom
+  // changes outside the guest (e.g. in the main browser), so we should
+  // create a separate HostZoomMap for the guest.
+  ZoomController::CreateForWebContents(contents);
+
+  FaviconTabHelper::CreateForWebContents(contents);
+  extensions::ChromeExtensionWebContentsObserver::CreateForWebContents(
+      contents);
+#if defined(ENABLE_PRINTING)
+#if defined(ENABLE_FULL_PRINTING)
+  printing::PrintViewManager::CreateForWebContents(contents);
+  printing::PrintPreviewMessageHandler::CreateForWebContents(contents);
+#else
+  printing::PrintViewManagerBasic::CreateForWebContents(contents);
+#endif  // defined(ENABLE_FULL_PRINTING)
+#endif  // defined(ENABLE_PRINTING)
+  PDFTabHelper::CreateForWebContents(contents);
+  web_view_permission_helper_.reset(new WebViewPermissionHelper(this));
+}
 
 void WebViewGuest::DidStopLoading() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEvent(new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
+  DispatchEventToEmbedder(
+      new GuestViewBase::Event(webview::kEventLoadStop, args.Pass()));
 }
 
 void WebViewGuest::EmbedderDestroyed() {
   // TODO(fsamuel): WebRequest event listeners for <webview> should survive
   // reparenting of a <webview> within a single embedder. Right now, we keep
   // around the browser state for the listener for the lifetime of the embedder.
   // Ideally, the lifetime of the listeners should match the lifetime of the
   // <webview> DOM node. Once http://crbug.com/156219 is resolved we can move
   // the call to RemoveWebViewEventListenersOnIOThread back to
   // WebViewGuest::WebContentsDestroyed.
@@ skipping 31 matching lines @@
                                        int32 level,
                                        const base::string16& message,
                                        int32 line_no,
                                        const base::string16& source_id) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   // Log levels are from base/logging.h: LogSeverity.
   args->SetInteger(webview::kLevel, level);
   args->SetString(webview::kMessage, message);
   args->SetInteger(webview::kLine, line_no);
   args->SetString(webview::kSourceId, source_id);
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
   return true;
 }
 
 void WebViewGuest::CloseContents(WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEvent(new GuestViewBase::Event(webview::kEventClose, args.Pass()));
+  DispatchEventToEmbedder(
+      new GuestViewBase::Event(webview::kEventClose, args.Pass()));
 }
 
 void WebViewGuest::FindReply(WebContents* source,
                              int request_id,
                              int number_of_matches,
                              const gfx::Rect& selection_rect,
                              int active_match_ordinal,
                              bool final_update) {
   find_helper_.FindReply(request_id, number_of_matches, selection_rect,
                          active_match_ordinal, final_update);
 }
 
 bool WebViewGuest::HandleContextMenu(
     const content::ContextMenuParams& params) {
   ContextMenuDelegate* menu_delegate =
       ContextMenuDelegate::FromWebContents(guest_web_contents());
   DCHECK(menu_delegate);
 
   pending_menu_ = menu_delegate->BuildMenu(guest_web_contents(), params);
 
   // Pass it to embedder.
   int request_id = ++pending_context_menu_request_id_;
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   scoped_ptr<base::ListValue> items =
       MenuModelToValue(pending_menu_->menu_model());
   args->Set(webview::kContextMenuItems, items.release());
   args->SetInteger(webview::kRequestId, request_id);
-  DispatchEvent(new GuestViewBase::Event(webview::kEventContextMenu,
-                                         args.Pass()));
+  DispatchEventToEmbedder(
+      new GuestViewBase::Event(webview::kEventContextMenu, args.Pass()));
   return true;
 }
 
 void WebViewGuest::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (!attached())
     return;
 
   if (HandleKeyboardShortcuts(event))
     return;
 
   // Send the unhandled keyboard events back to the embedder to reprocess them.
   // TODO(fsamuel): This introduces the possibility of out-of-order keyboard
   // events because the guest may be arbitrarily delayed when responding to
   // keyboard events. In that time, the embedder may have received and processed
   // additional key events. This needs to be fixed as soon as possible.
   // See http://crbug.com/229882.
   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
       web_contents(), event);
 }
 
 void WebViewGuest::LoadProgressChanged(content::WebContents* source,
                                        double progress) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, guest_web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              const std::string& error_type) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(guestview::kUrl, url.possibly_invalid_spec());
   args->SetString(guestview::kReason, error_type);
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadAbort, args.Pass()));
 }
 
 void WebViewGuest::OnUpdateFrameName(bool is_top_level,
                                      const std::string& name) {
   if (!is_top_level)
     return;
 
   if (name_ == name)
     return;
@@ skipping 38 matching lines @@
                              params.user_gesture,
                              new_guest->guest_web_contents());
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
 void WebViewGuest::RendererResponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
 void WebViewGuest::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
       DCHECK_EQ(content::Source<WebContents>(source).ptr(),
                 guest_web_contents());
@@ skipping 39 matching lines @@
   guest_web_contents()->GetController().GoToOffset(relative_index);
 }
 
 void WebViewGuest::Reload() {
   // TODO(fsamuel): Don't check for repost because we don't want to show
   // Chromium's repost warning. We might want to implement a separate API
   // for registering a callback if a repost is about to happen.
   guest_web_contents()->GetController().Reload(false);
 }
 
-void WebViewGuest::RequestFileSystemPermission(
-    const GURL& url,
-    bool allowed_by_default,
-    const base::Callback<void(bool)>& callback) {
-  base::DictionaryValue request_info;
-  request_info.Set(guestview::kUrl, new base::StringValue(url.spec()));
-  RequestPermission(
-      WEB_VIEW_PERMISSION_TYPE_FILESYSTEM,
-      request_info,
-      base::Bind(&WebViewGuest::OnWebViewFileSystemPermissionResponse,
-                 base::Unretained(this),
-                 callback),
-      allowed_by_default);
-}
-
-void WebViewGuest::OnWebViewFileSystemPermissionResponse(
-    const base::Callback<void(bool)>& callback,
-    bool allow,
-    const std::string& user_input) {
-  callback.Run(allow && attached());
-}
-
-void WebViewGuest::RequestGeolocationPermission(
-    int bridge_id,
-    const GURL& requesting_frame,
-    bool user_gesture,
-    const base::Callback<void(bool)>& callback) {
-  base::DictionaryValue request_info;
-  request_info.Set(guestview::kUrl,
-                   new base::StringValue(requesting_frame.spec()));
-  request_info.Set(guestview::kUserGesture,
-                   base::Value::CreateBooleanValue(user_gesture));
-
-  // It is safe to hold an unretained pointer to WebViewGuest because this
-  // callback is called from WebViewGuest::SetPermission.
-  const PermissionResponseCallback permission_callback =
-      base::Bind(&WebViewGuest::OnWebViewGeolocationPermissionResponse,
-                 base::Unretained(this),
-                 bridge_id,
-                 user_gesture,
-                 callback);
-  int request_id = RequestPermission(
-      WEB_VIEW_PERMISSION_TYPE_GEOLOCATION,
-      request_info,
-      permission_callback,
-      false /* allowed_by_default */);
-  bridge_id_to_request_id_map_[bridge_id] = request_id;
-}
-
-void WebViewGuest::OnWebViewGeolocationPermissionResponse(
-    int bridge_id,
-    bool user_gesture,
-    const base::Callback<void(bool)>& callback,
-    bool allow,
-    const std::string& user_input) {
-  // The <webview> embedder has allowed the permission. We now need to make sure
-  // that the embedder has geolocation permission.
-  RemoveBridgeID(bridge_id);
-
-  if (!allow || !attached()) {
-    callback.Run(false);
-    return;
-  }
-
-  Profile* profile = Profile::FromBrowserContext(browser_context());
-  GeolocationPermissionContextFactory::GetForProfile(profile)->
-      RequestGeolocationPermission(
-          embedder_web_contents(),
-          // The geolocation permission request here is not initiated
-          // through WebGeolocationPermissionRequest. We are only interested
-          // in the fact whether the embedder/app has geolocation
-          // permission. Therefore we use an invalid |bridge_id|.
-          -1,
-          embedder_web_contents()->GetLastCommittedURL(),
-          user_gesture,
-          callback,
-          NULL);
-}
-
-void WebViewGuest::CancelGeolocationPermissionRequest(int bridge_id) {
-  int request_id = RemoveBridgeID(bridge_id);
-  RequestMap::iterator request_itr =
-      pending_permission_requests_.find(request_id);
-
-  if (request_itr == pending_permission_requests_.end())
-    return;
-
-  pending_permission_requests_.erase(request_itr);
-}
-
-void WebViewGuest::OnWebViewMediaPermissionResponse(
-    const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback,
-    bool allow,
-    const std::string& user_input) {
-  if (!allow || !attached()) {
-    // Deny the request.
-    callback.Run(content::MediaStreamDevices(),
-                 content::MEDIA_DEVICE_INVALID_STATE,
-                 scoped_ptr<content::MediaStreamUI>());
-    return;
-  }
-  if (!embedder_web_contents()->GetDelegate())
-    return;
-
-  embedder_web_contents()->GetDelegate()->
-      RequestMediaAccessPermission(embedder_web_contents(), request, callback);
-}
-
-void WebViewGuest::OnWebViewDownloadPermissionResponse(
-    const base::Callback<void(bool)>& callback,
-    bool allow,
-    const std::string& user_input) {
-  callback.Run(allow && attached());
-}
-
-void WebViewGuest::OnWebViewPointerLockPermissionResponse(
-    const base::Callback<void(bool)>& callback,
-    bool allow,
-    const std::string& user_input) {
-  callback.Run(allow && attached());
-}
-
-WebViewGuest::SetPermissionResult WebViewGuest::SetPermission(
-    int request_id,
-    PermissionResponseAction action,
-    const std::string& user_input) {
-  RequestMap::iterator request_itr =
-      pending_permission_requests_.find(request_id);
-
-  if (request_itr == pending_permission_requests_.end())
-    return SET_PERMISSION_INVALID;
-
-  const PermissionResponseInfo& info = request_itr->second;
-  bool allow = (action == ALLOW) ||
-      ((action == DEFAULT) && info.allowed_by_default);
-
-  info.callback.Run(allow, user_input);
-
-  // Only record user initiated (i.e. non-default) actions.
-  if (action != DEFAULT)
-    RecordUserInitiatedUMA(info, allow);
-
-  pending_permission_requests_.erase(request_itr);
-
-  return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED;
-}
-
 void WebViewGuest::SetUserAgentOverride(
     const std::string& user_agent_override) {
   if (!attached())
     return;
   is_overriding_user_agent_ = !user_agent_override.empty();
   if (is_overriding_user_agent_) {
     content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA"));
   }
   guest_web_contents()->SetUserAgentOverride(user_agent_override);
 }
@@ skipping 26 matching lines @@
       removal_mask,
       content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
       GURL(),
       content::StoragePartition::OriginMatcherFunction(),
       remove_since,
       base::Time::Now(),
       callback);
   return true;
 }
 
-// static
-void WebViewGuest::FileSystemAccessedAsync(int render_process_id,
-                                           int render_frame_id,
-                                           int request_id,
-                                           const GURL& url,
-                                           bool blocked_by_policy) {
-  WebViewGuest* guest =
-      WebViewGuest::FromFrameID(render_process_id, render_frame_id);
-  DCHECK(guest);
-  guest->RequestFileSystemPermission(
-      url,
-      !blocked_by_policy,
-      base::Bind(&WebViewGuest::FileSystemAccessedAsyncResponse,
-                 render_process_id,
-                 render_frame_id,
-                 request_id,
-                 url));
-}
-
-// static
-void WebViewGuest::FileSystemAccessedAsyncResponse(int render_process_id,
-                                                   int render_frame_id,
-                                                   int request_id,
-                                                   const GURL& url,
-                                                   bool allowed) {
-  TabSpecificContentSettings::FileSystemAccessed(
-      render_process_id, render_frame_id, url, !allowed);
-  content::RenderFrameHost* render_frame_host =
-      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
-  if (!render_frame_host)
-    return;
-  render_frame_host->Send(
-      new ChromeViewMsg_RequestFileSystemAccessAsyncResponse(
-          render_frame_id, request_id, allowed));
-}
-
-// static
-void WebViewGuest::FileSystemAccessedSync(int render_process_id,
-                                          int render_frame_id,
-                                          const GURL& url,
-                                          bool blocked_by_policy,
-                                          IPC::Message* reply_msg) {
-  WebViewGuest* guest =
-      WebViewGuest::FromFrameID(render_process_id, render_frame_id);
-  DCHECK(guest);
-  guest->RequestFileSystemPermission(
-      url,
-      !blocked_by_policy,
-      base::Bind(&WebViewGuest::FileSystemAccessedSyncResponse,
-                 render_process_id,
-                 render_frame_id,
-                 url,
-                 reply_msg));
-}
-
-// static
-void WebViewGuest::FileSystemAccessedSyncResponse(int render_process_id,
-                                                  int render_frame_id,
-                                                  const GURL& url,
-                                                  IPC::Message* reply_msg,
-                                                  bool allowed) {
-  TabSpecificContentSettings::FileSystemAccessed(
-      render_process_id, render_frame_id, url, !allowed);
-  ChromeViewHostMsg_RequestFileSystemAccessSync::WriteReplyParams(reply_msg,
-                                                                  allowed);
-  content::RenderFrameHost* render_frame_host =
-      content::RenderFrameHost::FromID(render_process_id, render_frame_id);
-  if (!render_frame_id)
-    return;
-  render_frame_host->Send(reply_msg);
-}
-
 WebViewGuest::~WebViewGuest() {
 }
 
 void WebViewGuest::DidCommitProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& url,
     content::PageTransition transition_type) {
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, url.spec());
   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
   args->SetInteger(webview::kInternalCurrentEntryIndex,
       guest_web_contents()->GetController().GetCurrentEntryIndex());
   args->SetInteger(webview::kInternalEntryCount,
       guest_web_contents()->GetController().GetEntryCount());
   args->SetInteger(webview::kInternalProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadCommit, args.Pass()));
 
   // Update the current zoom factor for the new page.
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(guest_web_contents());
   DCHECK(zoom_controller);
   current_zoom_factor_ = zoom_controller->GetZoomLevel();
 
   if (!render_frame_host->GetParent()) {
     chromevox_injected_ = false;
@@ skipping 14 matching lines @@
 }
 
 void WebViewGuest::DidStartProvisionalLoadForFrame(
     content::RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     bool is_error_page,
     bool is_iframe_srcdoc) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, validated_url.spec());
   args->SetBoolean(guestview::kIsTopLevel, !render_frame_host->GetParent());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadStart, args.Pass()));
 }
 
 void WebViewGuest::DocumentLoadedInFrame(
     int64 frame_id,
     content::RenderViewHost* render_view_host) {
   if (frame_id == main_frame_id_)
     InjectChromeVoxIfNeeded(render_view_host);
 }
 
 bool WebViewGuest::OnMessageReceived(const IPC::Message& message,
                                      RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebViewGuest, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_UpdateFrameName, OnUpdateFrameName)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebViewGuest::RenderProcessGone(base::TerminationStatus status) {
   // Cancel all find sessions in progress.
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    guest_web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
-  DispatchEvent(new GuestViewBase::Event(webview::kEventExit, args.Pass()));
+  DispatchEventToEmbedder(
+      new GuestViewBase::Event(webview::kEventExit, args.Pass()));
 }
 
 void WebViewGuest::UserAgentOverrideSet(const std::string& user_agent) {
   if (!attached())
     return;
   content::NavigationController& controller =
       guest_web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetVisibleEntry();
   if (!entry)
     return;
   entry->SetIsOverridingUserAgent(!user_agent.empty());
   guest_web_contents()->GetController().Reload(false);
 }
 
 void WebViewGuest::RenderViewReady() {
   // The guest RenderView should always live in an isolated guest process.
   CHECK(guest_web_contents()->GetRenderProcessHost()->IsIsolatedGuest());
   Send(new ChromeViewMsg_SetName(guest_web_contents()->GetRoutingID(), name_));
 }
 
 void WebViewGuest::ReportFrameNameChange(const std::string& name) {
   name_ = name;
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(webview::kName, name);
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventFrameNameChanged, args.Pass()));
 }
 
 void WebViewGuest::LoadHandlerCalled() {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventContentLoad, args.Pass()));
 }
 
 void WebViewGuest::LoadRedirect(const GURL& old_url,
                                 const GURL& new_url,
                                 bool is_top_level) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetBoolean(guestview::kIsTopLevel, is_top_level);
   args->SetString(webview::kNewURL, new_url.spec());
   args->SetString(webview::kOldURL, old_url.spec());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventLoadRedirect, args.Pass()));
 }
 
 void WebViewGuest::PushWebViewStateToIOThread() {
   const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
   std::string partition_domain;
   std::string partition_id;
   bool in_memory;
   if (!GetGuestPartitionConfigForSite(
           site_url, &partition_domain, &partition_id, &in_memory)) {
@@ skipping 41 matching lines @@
       create_params);
 }
 
 void WebViewGuest::SizeChanged(const gfx::Size& old_size,
                                const gfx::Size& new_size) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 void WebViewGuest::RequestMediaAccessPermission(
     content::WebContents* source,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
-  base::DictionaryValue request_info;
-  request_info.Set(guestview::kUrl,
-                   new base::StringValue(request.security_origin.spec()));
-  RequestPermission(WEB_VIEW_PERMISSION_TYPE_MEDIA,
-                    request_info,
-                    base::Bind(&WebViewGuest::OnWebViewMediaPermissionResponse,
-                               base::Unretained(this),
-                               request,
-                               callback),
-                    false /* allowed_by_default */);
+  web_view_permission_helper_->RequestMediaAccessPermission(source,
+                                                            request,
+                                                            callback);
 }
 
 void WebViewGuest::CanDownload(
     content::RenderViewHost* render_view_host,
     const GURL& url,
     const std::string& request_method,
     const base::Callback<void(bool)>& callback) {
-  base::DictionaryValue request_info;
-  request_info.Set(guestview::kUrl, new base::StringValue(url.spec()));
-  RequestPermission(
-      WEB_VIEW_PERMISSION_TYPE_DOWNLOAD,
-      request_info,
-      base::Bind(&WebViewGuest::OnWebViewDownloadPermissionResponse,
-                 base::Unretained(this),
-                 callback),
-      false /* allowed_by_default */);
+  web_view_permission_helper_->CanDownload(render_view_host,
+                                           url,
+                                           request_method,
+                                           callback);
 }
 
 void WebViewGuest::RequestPointerLockPermission(
     bool user_gesture,
     bool last_unlocked_by_target,
     const base::Callback<void(bool)>& callback) {
-  base::DictionaryValue request_info;
-  request_info.Set(guestview::kUserGesture,
-                   base::Value::CreateBooleanValue(user_gesture));
-  request_info.Set(webview::kLastUnlockedBySelf,
-                   base::Value::CreateBooleanValue(last_unlocked_by_target));
-  request_info.Set(guestview::kUrl,
-                   new base::StringValue(
-                       guest_web_contents()->GetLastCommittedURL().spec()));
-
-  RequestPermission(
-      WEB_VIEW_PERMISSION_TYPE_POINTER_LOCK,
-      request_info,
-      base::Bind(&WebViewGuest::OnWebViewPointerLockPermissionResponse,
-                 base::Unretained(this),
-                 callback),
-      false /* allowed_by_default */);
+  web_view_permission_helper_->RequestPointerLockPermission(
+      user_gesture,
+      last_unlocked_by_target,
+      callback);
 }
 
 void WebViewGuest::WillAttachToEmbedder() {
   // We must install the mapping from guests to WebViews prior to resuming
   // suspended resource loads so that the WebRequest API will catch resource
   // requests.
   PushWebViewStateToIOThread();
 }
 
 content::JavaScriptDialogManager*
@@ skipping 73 matching lines @@
     chromeos::AccessibilityManager* manager =
         chromeos::AccessibilityManager::Get();
     if (manager && manager->IsSpokenFeedbackEnabled()) {
       manager->InjectChromeVox(render_view_host);
       chromevox_injected_ = true;
     }
   }
 #endif
 }
 
-int WebViewGuest::RemoveBridgeID(int bridge_id) {
-  std::map<int, int>::iterator bridge_itr =
-      bridge_id_to_request_id_map_.find(bridge_id);
-  if (bridge_itr == bridge_id_to_request_id_map_.end())
-    return webview::kInvalidPermissionRequestID;
-
-  int request_id = bridge_itr->second;
-  bridge_id_to_request_id_map_.erase(bridge_itr);
-  return request_id;
-}
-
-int WebViewGuest::RequestPermission(
-    WebViewPermissionType permission_type,
-    const base::DictionaryValue& request_info,
-    const PermissionResponseCallback& callback,
-    bool allowed_by_default) {
-  // If there are too many pending permission requests then reject this request.
-  if (pending_permission_requests_.size() >=
-      webview::kMaxOutstandingPermissionRequests) {
-    // Let the stack unwind before we deny the permission request so that
-    // objects held by the permission request are not destroyed immediately
-    // after creation. This is to allow those same objects to be accessed again
-    // in the same scope without fear of use after freeing.
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&PermissionResponseCallback::Run,
-                  base::Owned(new PermissionResponseCallback(callback)),
-                  allowed_by_default,
-                  std::string()));
-    return webview::kInvalidPermissionRequestID;
-  }
-
-  int request_id = next_permission_request_id_++;
-  pending_permission_requests_[request_id] =
-      PermissionResponseInfo(callback, permission_type, allowed_by_default);
-  scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy());
-  args->SetInteger(webview::kRequestId, request_id);
-  switch (permission_type) {
-    case WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW: {
-      DispatchEvent(
-          new GuestViewBase::Event(webview::kEventNewWindow, args.Pass()));
-      break;
-    }
-    case WEB_VIEW_PERMISSION_TYPE_JAVASCRIPT_DIALOG: {
-      DispatchEvent(
-          new GuestViewBase::Event(webview::kEventDialog, args.Pass()));
-      break;
-    }
-    default: {
-      args->SetString(webview::kPermission,
-                      PermissionTypeToString(permission_type));
-      DispatchEvent(new GuestViewBase::Event(webview::kEventPermissionRequest,
-                                             args.Pass()));
-      break;
-    }
-  }
-  return request_id;
-}
-
 bool WebViewGuest::HandleKeyboardShortcuts(
     const content::NativeWebKeyboardEvent& event) {
   if (event.type != blink::WebInputEvent::RawKeyDown)
     return false;
 
   // If the user hits the escape key without any modifiers then unlock the
   // mouse if necessary.
   if ((event.windowsKeyCode == ui::VKEY_ESCAPE) &&
       !(event.modifiers & blink::WebInputEvent::InputModifiers)) {
     return guest_web_contents()->GotResponseToLockMouseRequest(false);
@@ skipping 20 matching lines @@
 
   if (event.windowsKeyCode == ui::VKEY_BROWSER_FORWARD) {
     Go(1);
     return true;
   }
 #endif
 
   return false;
 }
 
-WebViewGuest::PermissionResponseInfo::PermissionResponseInfo()
-    : permission_type(WEB_VIEW_PERMISSION_TYPE_UNKNOWN),
-      allowed_by_default(false) {
-}
-
-WebViewGuest::PermissionResponseInfo::PermissionResponseInfo(
-    const PermissionResponseCallback& callback,
-    WebViewPermissionType permission_type,
-    bool allowed_by_default)
-    : callback(callback),
-      permission_type(permission_type),
-      allowed_by_default(allowed_by_default) {
-}
-
-WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
-}
-
 void WebViewGuest::ShowContextMenu(int request_id,
                                    const MenuItemVector* items) {
   if (!pending_menu_.get())
     return;
 
   // Make sure this was the correct request.
   if (request_id != pending_context_menu_request_id_)
     return;
 
   // TODO(lazyboy): Implement.
@@ skipping 15 matching lines @@
 void WebViewGuest::SetZoom(double zoom_factor) {
   ZoomController* zoom_controller =
       ZoomController::FromWebContents(guest_web_contents());
   DCHECK(zoom_controller);
   double zoom_level = content::ZoomFactorToZoomLevel(zoom_factor);
   zoom_controller->SetZoomLevel(zoom_level);
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetDouble(webview::kOldZoomFactor, current_zoom_factor_);
   args->SetDouble(webview::kNewZoomFactor, zoom_factor);
-  DispatchEvent(
+  DispatchEventToEmbedder(
       new GuestViewBase::Event(webview::kEventZoomChange, args.Pass()));
 
   current_zoom_factor_ = zoom_factor;
 }
 
 void WebViewGuest::AddNewContents(content::WebContents* source,
                                   content::WebContents* new_contents,
                                   WindowOpenDisposition disposition,
                                   const gfx::Rect& initial_pos,
                                   bool user_gesture,
@@ skipping 94 matching lines @@
                    base::Value::CreateIntegerValue(
                       guest->GetGuestInstanceID()));
   // We pass in partition info so that window-s created through newwindow
   // API can use it to set their partition attribute.
   request_info.Set(webview::kStoragePartitionId,
                    new base::StringValue(storage_partition_id));
   request_info.Set(
       webview::kWindowOpenDisposition,
       new base::StringValue(WindowOpenDispositionToString(disposition)));
 
-  RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
-                    request_info,
-                    base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
-                               base::Unretained(this),
-                               guest->GetGuestInstanceID()),
-                               false /* allowed_by_default */);
+  web_view_permission_helper_->
+      RequestPermission(WEB_VIEW_PERMISSION_TYPE_NEW_WINDOW,
+                        request_info,
+                        base::Bind(&WebViewGuest::OnWebViewNewWindowResponse,
+                                   base::Unretained(this),
+                                   guest->GetGuestInstanceID()),
+                                   false /* allowed_by_default */);
 }
 
 void WebViewGuest::DestroyUnattachedWindows() {
   // Destroy() reaches in and removes the WebViewGuest from its opener's
   // pending_new_windows_ set. To avoid mutating the set while iterating, we
   // create a copy of the pending new windows set and iterate over the copy.
   PendingWindowMap pending_new_windows(pending_new_windows_);
   // Clean up unattached new windows opened by this guest.
   for (PendingWindowMap::const_iterator it = pending_new_windows.begin();
        it != pending_new_windows.end(); ++it) {
@@ skipping 21 matching lines @@
     bool allow,
     const std::string& user_input) {
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }