<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.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 491 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;
+  }
   AddPermissionRequestToMap(request_id, permission_type);
 
   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 437 matching lines @@
   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(
-    BrowserPluginPermissionType permission_type, int request_id, bool allow) {
+    BrowserPluginPermissionType permission_type,
+    int request_id,
+    bool allow,
+    const std::string& user_input) {
   if (permission_type == BrowserPluginPermissionTypePointerLock)
       RespondPermissionPointerLock(allow);
   else
     browser_plugin_manager()->Send(
         new BrowserPluginHostMsg_RespondPermission(
-            render_view_routing_id_, guest_instance_id_, permission_type,
-            request_id, allow));
+            render_view_routing_id_, guest_instance_id_,
+            request_id, allow, user_input));
 }
 
 void BrowserPlugin::RespondPermissionPointerLock(bool allow) {
   if (allow)
     render_view_->mouse_lock_dispatcher()->LockMouse(this);
   else
     OnLockMouseACK(false);
 }
 
 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;
 
   BrowserPluginPermissionType permission_type = iter->second;
   pending_permission_requests_.erase(iter);
-  RespondPermission(permission_type, request_id, allow);
+  RespondPermission(permission_type, 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 448 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