<webview>: Implement dialog API

content/renderer/browser_plugin/browser_plugin.cc

 // Copyright 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/renderer/browser_plugin/browser_plugin.h"
 
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 53 matching lines @@
     case BrowserPluginPermissionTypeDownload:
       return browser_plugin::kPermissionTypeDownload;
     case BrowserPluginPermissionTypeGeolocation:
       return browser_plugin::kPermissionTypeGeolocation;
     case BrowserPluginPermissionTypeMedia:
       return browser_plugin::kPermissionTypeMedia;
     case BrowserPluginPermissionTypeNewWindow:
       return browser_plugin::kPermissionTypeNewWindow;
     case BrowserPluginPermissionTypePointerLock:
       return browser_plugin::kPermissionTypePointerLock;
+    case BrowserPluginPermissionTypeJavaScriptDialog:
+      return browser_plugin::kPermissionTypeDialog;
     case BrowserPluginPermissionTypeUnknown:
     default:
       NOTREACHED();
       break;
   }
   return std::string();
 }
 
 typedef std::map<WebKit::WebPluginContainer*,
                  BrowserPlugin*> PluginContainerMap;
@@ skipping 412 matching lines @@
 }
 
 void BrowserPlugin::OnRequestPermission(
     int guest_instance_id,
     BrowserPluginPermissionType permission_type,
     int request_id,
     const base::DictionaryValue& request_info) {
   // The New Window API is very similiar to the permission API in structure,
   // but exposes a slightly different interface to the developer and so we put
   // it in a separate event.
-  const char* event_name =
-      (permission_type == BrowserPluginPermissionTypeNewWindow) ?
-          browser_plugin::kEventNewWindow :
-              browser_plugin::kEventRequestPermission;
-
+  const char* event_name = NULL;
+  if (permission_type == BrowserPluginPermissionTypeNewWindow) {
+    event_name = browser_plugin::kEventNewWindow;
+  } else if (permission_type == BrowserPluginPermissionTypeJavaScriptDialog) {
+    event_name = browser_plugin::kEventDialog;
+  } else {
+    event_name = browser_plugin::kEventRequestPermission;
+  }
   AddPermissionRequestToSet(request_id);
 
   std::map<std::string, base::Value*> props;
   props[browser_plugin::kPermission] =
       base::Value::CreateStringValue(PermissionTypeToString(permission_type));
   props[browser_plugin::kRequestId] =
       base::Value::CreateIntegerValue(request_id);
 
   // Fill in the info provided by the browser.
   for (DictionaryValue::Iterator iter(request_info); !iter.IsAtEnd();
@@ skipping 446 matching lines @@
   bool embedder_focused = false;
   if (render_view_.get())
     embedder_focused = render_view_->has_focus();
   return plugin_focused_ && embedder_focused;
 }
 
 WebKit::WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
-void BrowserPlugin::RespondPermission(int request_id, bool allow) {
+void BrowserPlugin::RespondPermission(
+    int request_id, bool allow, const std::string& user_input) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_RespondPermission(
-          render_view_routing_id_, guest_instance_id_, request_id, allow));
+          render_view_routing_id_, guest_instance_id_,
+          request_id, allow, user_input));
 }
 
 void BrowserPlugin::RespondPermissionIfRequestIsPending(
-    int request_id, bool allow) {
+    int request_id, bool allow, const std::string& user_input) {
   PendingPermissionRequests::iterator iter =
       pending_permission_requests_.find(request_id);
   if (iter == pending_permission_requests_.end())
     return;
 
   pending_permission_requests_.erase(iter);
-  RespondPermission(request_id, allow);
+  RespondPermission(request_id, allow, user_input);
 }
 
-void BrowserPlugin::OnEmbedderDecidedPermission(int request_id, bool allow) {
-  RespondPermissionIfRequestIsPending(request_id, allow);
+void BrowserPlugin::OnEmbedderDecidedPermission(int request_id,
+                                                bool allow,
+                                                const std::string& user_input) {
+  RespondPermissionIfRequestIsPending(request_id, allow, user_input);
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   if (!container)
     return false;
 
   if (!GetContentClient()->renderer()->AllowBrowserPlugin(container))
     return false;
 
   // Tell |container| to allow this plugin to use script objects.
@@ skipping 451 matching lines @@
     const WebKit::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 guest_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content