<webview>: Refactor Permission API to chrome

chrome/browser/guestview/webview/webview_guest.cc

 // Copyright 2013 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/guestview/webview/webview_guest.h"
 
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
 #include "chrome/browser/extensions/script_executor.h"
 #include "chrome/browser/guestview/guestview_constants.h"
@@ skipping 25 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(BrowserPluginPermissionType type) {
+  switch (type) {
+    case BrowserPluginPermissionTypeDownload:
+      return webview::kPermissionTypeDownload;
+    case BrowserPluginPermissionTypeGeolocation:
+      return webview::kPermissionTypeGeolocation;
+    case BrowserPluginPermissionTypeMedia:
+      return webview::kPermissionTypeMedia;
+    case BrowserPluginPermissionTypeNewWindow:
+      return webview::kPermissionTypeNewWindow;
+    case BrowserPluginPermissionTypePointerLock:
+      return webview::kPermissionTypePointerLock;
+    case BrowserPluginPermissionTypeJavaScriptDialog:
+      return webview::kPermissionTypeDialog;
+    case BrowserPluginPermissionTypeUnknown:
+    default:
+      NOTREACHED();
+      break;
+  }
+  return std::string();
+}
+
 void RemoveWebViewEventListenersOnIOThread(
     void* profile,
     const std::string& extension_id,
     int embedder_process_id,
     int guest_instance_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   ExtensionWebRequestEventRouter::GetInstance()->RemoveWebViewEventListeners(
       profile, extension_id, embedder_process_id, guest_instance_id);
 }
 
 }  // namespace
 
 WebViewGuest::WebViewGuest(WebContents* guest_web_contents)
     : GuestView(guest_web_contents),
       WebContentsObserver(guest_web_contents),
       script_executor_(new extensions::ScriptExecutor(guest_web_contents,
-                                                      &script_observers_)) {
+                                                      &script_observers_)),
+      next_permission_request_id_(0) {
   notification_registrar_.Add(
       this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       content::Source<WebContents>(guest_web_contents));
 
   notification_registrar_.Add(
       this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
       content::Source<WebContents>(guest_web_contents));
 }
 
 // static
@@ skipping 95 matching lines @@
   DispatchEvent(new GuestView::Event(webview::kEventResponsive, args.Pass()));
 }
 
 void WebViewGuest::RendererUnresponsive() {
   scoped_ptr<DictionaryValue> args(new DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(new GuestView::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
+bool WebViewGuest::RequestPermission(
+    BrowserPluginPermissionType permission_type,
+    const base::DictionaryValue& request_info,
+    const PermissionResponseCallback& callback) {
+  int request_id = next_permission_request_id_++;
+  pending_permission_requests_[request_id] = callback;
+  scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy());
+  args->SetInteger(webview::kRequestId, request_id);
+  switch (permission_type) {
+    case BrowserPluginPermissionTypeNewWindow: {
+      DispatchEvent(new GuestView::Event(webview::kEventNewWindow,
+                                         args.Pass()));
+      break;
+    }
+    case BrowserPluginPermissionTypeJavaScriptDialog: {
+      DispatchEvent(new GuestView::Event(webview::kEventDialog,
+                                         args.Pass()));
+      break;
+    }
+    default: {
+      args->SetString(webview::kPermission,
+                      PermissionTypeToString(permission_type));
+      DispatchEvent(new GuestView::Event(webview::kEventPermissionRequest,
+                                         args.Pass()));
+      break;
+    }
+  }
+  return true;
+}
+
 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());
       if (content::Source<WebContents>(source).ptr() == guest_web_contents())
         LoadHandlerCalled();
       break;
@@ skipping 20 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);
 }
 
+bool WebViewGuest::SetPermission(int request_id,
+                                 bool should_allow,
+                                 const std::string& user_input) {
+  RequestMap::iterator request_itr =
+      pending_permission_requests_.find(request_id);
+
+  if (request_itr == pending_permission_requests_.end())
+    return false;
+
+  request_itr->second.Run(should_allow, user_input);
+  pending_permission_requests_.erase(request_itr);
+  return true;
+}
+
 void WebViewGuest::Stop() {
   guest_web_contents()->Stop();
 }
 
 void WebViewGuest::Terminate() {
   content::RecordAction(content::UserMetricsAction("WebView.Guest.Terminate"));
   base::ProcessHandle process_handle =
       guest_web_contents()->GetRenderProcessHost()->GetHandle();
   if (process_handle)
     base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
@@ skipping 104 matching lines @@
 void WebViewGuest::RemoveWebViewFromExtensionRendererState(
     WebContents* web_contents) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(
           &ExtensionRendererState::RemoveWebView,
           base::Unretained(ExtensionRendererState::GetInstance()),
           web_contents->GetRenderProcessHost()->GetID(),
           web_contents->GetRoutingID()));
 }