<webview>: Refactor Permission API to chrome

content/browser/browser_plugin/browser_plugin_guest.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 "content/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 328 matching lines @@
       damage_buffer_sequence_id_(0),
       damage_buffer_size_(0),
       damage_buffer_scale_factor_(1.0f),
       guest_device_scale_factor_(1.0f),
       guest_hang_timeout_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       focused_(false),
       mouse_locked_(false),
       pending_lock_request_(false),
       embedder_visible_(true),
-      next_permission_request_id_(0),
+      next_permission_request_id_(browser_plugin::kInvalidPermissionRequestID),
       has_render_view_(has_render_view) {
   DCHECK(web_contents);
   web_contents->SetDelegate(this);
   if (opener)
     opener_ = opener->AsWeakPtr();
   GetWebContents()->GetBrowserPluginGuestManager()->AddGuest(instance_id_,
                                                              GetWebContents());
 }
 
 bool BrowserPluginGuest::AddMessageToConsole(WebContents* source,
@@ skipping 16 matching lines @@
   // Clean up unattached new windows opened by this guest.
   for (PendingWindowMap::const_iterator it = pending_new_windows.begin();
        it != pending_new_windows.end(); ++it) {
     it->first->Destroy();
   }
   // All pending windows should be removed from the set after Destroy() is
   // called on all of them.
   DCHECK_EQ(0ul, pending_new_windows_.size());
 }
 
+void BrowserPluginGuest::RespondToPermissionRequest(
+    int request_id,
+    bool should_allow,
+    const std::string& user_input) {
+  RequestMap::iterator request_itr = permission_request_map_.find(request_id);
+  if (request_itr == permission_request_map_.end()) {
+    LOG(INFO) << "Not a valid request ID.";
+    return;
+  }
+  request_itr->second->Respond(should_allow, user_input);
+  permission_request_map_.erase(request_itr);
+}
+
 int BrowserPluginGuest::RequestPermission(
     BrowserPluginPermissionType permission_type,
     scoped_refptr<BrowserPluginGuest::PermissionRequest> request,
     const base::DictionaryValue& request_info) {
-  int request_id = next_permission_request_id_++;
+  if (!delegate_) {
+    request->Respond(false, "");
+    return browser_plugin::kInvalidPermissionRequestID;
+  }
+
+  int request_id = ++next_permission_request_id_;
   permission_request_map_[request_id] = request;
 
-  SendMessageToEmbedder(new BrowserPluginMsg_RequestPermission(
-      instance_id(), permission_type, request_id, request_info));
+  BrowserPluginGuestDelegate::PermissionResponseCallback callback =
+      base::Bind(&BrowserPluginGuest::RespondToPermissionRequest,
+                  AsWeakPtr(),
+                  request_id);
+  // If BrowserPluginGuestDelegate hasn't handled the permission then we simply
+  // reject it immediately.
+  if (!delegate_->RequestPermission(permission_type, request_info, callback))
+    callback.Run(false, "");
 
   return request_id;
 }
 
 void BrowserPluginGuest::Destroy() {
   if (!attached() && opener())
     opener()->pending_new_windows_.erase(this);
   DestroyUnattachedWindows();
   GetWebContents()->GetBrowserPluginGuestManager()->RemoveGuest(instance_id_);
   delete GetWebContents();
@@ skipping 10 matching lines @@
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_DragStatusUpdate,
                         OnDragStatusUpdate)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ExecuteEditCommand,
                         OnExecuteEditCommand)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_HandleInputEvent,
                         OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_LockMouse_ACK, OnLockMouseAck)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_NavigateGuest, OnNavigateGuest)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_PluginDestroyed, OnPluginDestroyed)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_ResizeGuest, OnResizeGuest)
-    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_RespondPermission,
-                        OnRespondPermission)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetAutoSize, OnSetSize)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetEditCommandsForNextKeyEvent,
                         OnSetEditCommandsForNextKeyEvent)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetName, OnSetName)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetVisibility, OnSetVisibility)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UnlockMouse_ACK, OnUnlockMouseAck)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateGeometry, OnUpdateGeometry)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateRect_ACK, OnUpdateRectACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 365 matching lines @@
   request_info.Set(browser_plugin::kTargetURL,
                    base::Value::CreateStringValue(new_window_info.url.spec()));
   request_info.Set(browser_plugin::kName,
                    base::Value::CreateStringValue(new_window_info.name));
   request_info.Set(browser_plugin::kWindowID,
                    base::Value::CreateIntegerValue(guest->instance_id()));
   request_info.Set(browser_plugin::kWindowOpenDisposition,
                    base::Value::CreateStringValue(
                        WindowOpenDispositionToString(disposition)));
 
-  RequestPermission(BrowserPluginPermissionTypeNewWindow,
+  RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW,
                     new NewWindowRequest(guest->instance_id(), this),
                     request_info);
 }
 
 bool BrowserPluginGuest::UnlockMouseIfNecessary(
     const NativeWebKeyboardEvent& event) {
   if (!mouse_locked_)
     return false;
 
   embedder_web_contents()->GotResponseToLockMouseRequest(false);
@@ skipping 50 matching lines @@
     // Deny the geolocation request.
     callback.Run(false);
     return;
   }
 
   base::DictionaryValue request_info;
   request_info.Set(browser_plugin::kURL,
                    base::Value::CreateStringValue(requesting_frame.spec()));
 
   int request_id =
-      RequestPermission(BrowserPluginPermissionTypeGeolocation,
+      RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION,
                         new GeolocationRequest(
                             callback, bridge_id, &weak_ptr_factory_),
                         request_info);
 
   DCHECK(bridge_id_to_request_id_map_.find(bridge_id) ==
          bridge_id_to_request_id_map_.end());
   bridge_id_to_request_id_map_[bridge_id] = request_id;
 }
 
 int BrowserPluginGuest::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 -1;
+    return browser_plugin::kInvalidPermissionRequestID;
 
   int request_id = bridge_itr->second;
   bridge_id_to_request_id_map_.erase(bridge_itr);
   return request_id;
 }
 
 void BrowserPluginGuest::CancelGeolocationRequest(int bridge_id) {
   int request_id = RemoveBridgeID(bridge_id);
   RequestMap::iterator request_itr = permission_request_map_.find(request_id);
   if (request_itr == permission_request_map_.end())
@@ skipping 101 matching lines @@
   switch (message.type()) {
     case BrowserPluginHostMsg_BuffersSwappedACK::ID:
     case BrowserPluginHostMsg_CompositorFrameACK::ID:
     case BrowserPluginHostMsg_DragStatusUpdate::ID:
     case BrowserPluginHostMsg_ExecuteEditCommand::ID:
     case BrowserPluginHostMsg_HandleInputEvent::ID:
     case BrowserPluginHostMsg_LockMouse_ACK::ID:
     case BrowserPluginHostMsg_NavigateGuest::ID:
     case BrowserPluginHostMsg_PluginDestroyed::ID:
     case BrowserPluginHostMsg_ResizeGuest::ID:
-    case BrowserPluginHostMsg_RespondPermission::ID:
     case BrowserPluginHostMsg_SetAutoSize::ID:
     case BrowserPluginHostMsg_SetEditCommandsForNextKeyEvent::ID:
     case BrowserPluginHostMsg_SetFocus::ID:
     case BrowserPluginHostMsg_SetName::ID:
     case BrowserPluginHostMsg_SetVisibility::ID:
     case BrowserPluginHostMsg_UnlockMouse_ACK::ID:
     case BrowserPluginHostMsg_UpdateGeometry::ID:
     case BrowserPluginHostMsg_UpdateRect_ACK::ID:
       return true;
     default:
@@ skipping 203 matching lines @@
   pending_lock_request_ = true;
   base::DictionaryValue request_info;
   request_info.Set(browser_plugin::kUserGesture,
                    base::Value::CreateBooleanValue(user_gesture));
   request_info.Set(browser_plugin::kLastUnlockedBySelf,
                    base::Value::CreateBooleanValue(last_unlocked_by_target));
   request_info.Set(browser_plugin::kURL,
                    base::Value::CreateStringValue(
                        web_contents()->GetURL().spec()));
 
-  RequestPermission(BrowserPluginPermissionTypePointerLock,
+  RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_POINTER_LOCK,
                     new PointerLockRequest(this),
                     request_info);
 }
 
 void BrowserPluginGuest::OnLockMouseAck(int instance_id, bool succeeded) {
   Send(new ViewMsg_LockMouse_ACK(routing_id(), succeeded));
   pending_lock_request_ = false;
   if (succeeded)
     mouse_locked_ = true;
 }
@@ skipping 110 matching lines @@
 }
 
 void BrowserPluginGuest::OnSetVisibility(int instance_id, bool visible) {
   guest_visible_ = visible;
   if (embedder_visible_ && guest_visible_)
     GetWebContents()->WasShown();
   else
     GetWebContents()->WasHidden();
 }
 
-void BrowserPluginGuest::OnRespondPermission(
-    int instance_id,
-    int request_id,
-    bool should_allow,
-    const std::string& user_input) {
-  RequestMap::iterator request_itr = permission_request_map_.find(request_id);
-  if (request_itr == permission_request_map_.end()) {
-    LOG(INFO) << "Not a valid request ID.";
-    return;
-  }
-  request_itr->second->Respond(should_allow, user_input);
-  permission_request_map_.erase(request_itr);
-}
-
 void BrowserPluginGuest::OnSwapBuffersACK(int instance_id,
                                           int route_id,
                                           int gpu_host_id,
                                           const std::string& mailbox_name,
                                           uint32 sync_point) {
   AcknowledgeBufferPresent(route_id, gpu_host_id, mailbox_name, sync_point);
 
 // This is only relevant on MACOSX and WIN when threaded compositing
 // is not enabled. In threaded mode, above ACK is sufficient.
 #if defined(OS_MACOSX) || defined(OS_WIN)
@@ skipping 94 matching lines @@
     // Deny the media request.
     callback.Run(MediaStreamDevices(), scoped_ptr<MediaStreamUI>());
     return;
   }
 
   base::DictionaryValue request_info;
   request_info.Set(
       browser_plugin::kURL,
       base::Value::CreateStringValue(request.security_origin.spec()));
 
-  RequestPermission(BrowserPluginPermissionTypeMedia,
+  RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_MEDIA,
                     new MediaRequest(request, callback, this),
                     request_info);
 }
 
 void BrowserPluginGuest::RunJavaScriptDialog(
     WebContents* web_contents,
     const GURL& origin_url,
     const std::string& accept_lang,
     JavaScriptMessageType javascript_message_type,
     const string16& message_text,
@@ skipping 13 matching lines @@
       browser_plugin::kMessageText,
       base::Value::CreateStringValue(UTF16ToUTF8(message_text)));
   request_info.Set(
       browser_plugin::kMessageType,
       base::Value::CreateStringValue(
           JavaScriptMessageTypeToString(javascript_message_type)));
   request_info.Set(
       browser_plugin::kURL,
       base::Value::CreateStringValue(origin_url.spec()));
 
-  RequestPermission(BrowserPluginPermissionTypeJavaScriptDialog,
+  RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG,
                     new JavaScriptDialogRequest(callback),
                     request_info);
 }
 
 void BrowserPluginGuest::RunBeforeUnloadDialog(
     WebContents* web_contents,
     const string16& message_text,
     bool is_reload,
     const DialogClosedCallback& callback) {
   // This is called if the guest has a beforeunload event handler.
@@ skipping 76 matching lines @@
   if (url.empty()) {
     callback.Run(false);
     return;
   }
 
   base::DictionaryValue request_info;
   request_info.Set(browser_plugin::kRequestMethod,
                    base::Value::CreateStringValue(request_method));
   request_info.Set(browser_plugin::kURL, base::Value::CreateStringValue(url));
 
-  RequestPermission(BrowserPluginPermissionTypeDownload,
+  RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD,
                     new DownloadRequest(callback),
                     request_info);
 }
 
 }  // namespace content