<webview>: Implement dialog API

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.h"
@@ skipping 43 matching lines @@
 
 namespace content {
 
 // static
 BrowserPluginHostFactory* BrowserPluginGuest::factory_ = NULL;
 
 // Parent class for the various types of permission requests, each of which
 // should be able to handle the response to their permission request.
 class BrowserPluginGuest::PermissionRequest {
  public:
-  virtual void Respond(bool should_allow) = 0;
+  virtual void Respond(bool should_allow, const std::string& user_input) = 0;
   virtual ~PermissionRequest() {}
+  virtual BrowserPluginPermissionType GetType() const = 0;
  protected:
   PermissionRequest() {
     RecordAction(UserMetricsAction("BrowserPlugin.Guest.PermissionRequest"));
   }
 };
 
 class BrowserPluginGuest::DownloadRequest : public PermissionRequest {
  public:
   explicit DownloadRequest(base::Callback<void(bool)> callback)
       : callback_(callback) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Download"));
   }
-  virtual void Respond(bool should_allow) OVERRIDE {
+  virtual void Respond(bool should_allow,
+                       const std::string& user_input) OVERRIDE {
     callback_.Run(should_allow);
   }
+  virtual BrowserPluginPermissionType GetType() const OVERRIDE {
+    return BrowserPluginPermissionTypeDownload;
+  }
   virtual ~DownloadRequest() {}
  private:
   base::Callback<void(bool)> callback_;
 };
 
 class BrowserPluginGuest::GeolocationRequest : public PermissionRequest {
  public:
   GeolocationRequest(GeolocationCallback callback,
                      int bridge_id,
                      BrowserPluginGuest* guest,
                      base::WeakPtrFactory<BrowserPluginGuest>* weak_ptr_factory)
                      : callback_(callback),
                        bridge_id_(bridge_id),
                        guest_(guest),
                        weak_ptr_factory_(weak_ptr_factory) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Geolocation"));
   }
 
-  virtual void Respond(bool should_allow) OVERRIDE {
+  virtual void Respond(bool should_allow,
+                       const std::string& user_input) OVERRIDE {
     WebContents* web_contents = guest_->embedder_web_contents();
     if (should_allow && web_contents) {
       // If renderer side embedder decides to allow gelocation, we need to check
       // if the app/embedder itself has geolocation access.
       BrowserContext* browser_context = web_contents->GetBrowserContext();
       if (browser_context) {
         GeolocationPermissionContext* geolocation_context =
             browser_context->GetGeolocationPermissionContext();
         if (geolocation_context) {
           base::Callback<void(bool)> geolocation_callback = base::Bind(
@@ skipping 10 matching lines @@
               // permission. Therefore we use an invalid |bridge_id|.
               -1 /* bridge_id */,
               web_contents->GetURL(),
               geolocation_callback);
           return;
         }
       }
     }
     guest_->SetGeolocationPermission(callback_, bridge_id_, false);
   }
+  virtual BrowserPluginPermissionType GetType() const OVERRIDE {
+    return BrowserPluginPermissionTypeGeolocation;
+  }
   virtual ~GeolocationRequest() {}
  private:
   base::Callback<void(bool)> callback_;
   int bridge_id_;
   BrowserPluginGuest* guest_;
   base::WeakPtrFactory<BrowserPluginGuest>* weak_ptr_factory_;
 };
 
 class BrowserPluginGuest::MediaRequest : public PermissionRequest {
  public:
   MediaRequest(const MediaStreamRequest& request,
                const MediaResponseCallback& callback,
                BrowserPluginGuest* guest)
                : request_(request),
                  callback_(callback),
                  guest_(guest) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Media"));
   }
 
-  virtual void Respond(bool should_allow) OVERRIDE {
+  virtual void Respond(bool should_allow,
+                       const std::string& user_input) OVERRIDE {
     WebContentsImpl* web_contents = guest_->embedder_web_contents();
     if (should_allow && web_contents) {
       // Re-route the request to the embedder's WebContents; the guest gets the
       // permission this way.
       web_contents->RequestMediaAccessPermission(request_, callback_);
     } else {
       // Deny the request.
       callback_.Run(MediaStreamDevices(), scoped_ptr<MediaStreamUI>());
     }
-
+  }
+  virtual BrowserPluginPermissionType GetType() const OVERRIDE {
+    return BrowserPluginPermissionTypeMedia;
   }
   virtual ~MediaRequest() {}
  private:
   MediaStreamRequest request_;
   MediaResponseCallback callback_;
   BrowserPluginGuest* guest_;
 };
 
 class BrowserPluginGuest::NewWindowRequest : public PermissionRequest {
  public:
   NewWindowRequest(int instance_id, BrowserPluginGuest* guest)
       : instance_id_(instance_id),
         guest_(guest) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.NewWindow"));
   }
 
-  virtual void Respond(bool should_allow) OVERRIDE {
+  virtual void Respond(bool should_allow,
+                       const std::string& user_input) OVERRIDE {
     int embedder_render_process_id =
         guest_->embedder_web_contents()->GetRenderProcessHost()->GetID();
     BrowserPluginGuest* guest =
         guest_->GetWebContents()->GetBrowserPluginGuestManager()->
             GetGuestByInstanceID(instance_id_, embedder_render_process_id);
     if (!guest) {
       LOG(INFO) << "Guest not found. Instance ID: " << instance_id_;
       return;
     }
 
     // If we do not destroy the guest then we allow the new window.
     if (!should_allow)
       guest->Destroy();
   }
+  virtual BrowserPluginPermissionType GetType() const OVERRIDE {
+    return BrowserPluginPermissionTypeNewWindow;
+  }
   virtual ~NewWindowRequest() {}
  private:
   int instance_id_;
   BrowserPluginGuest* guest_;
 };
 
+class BrowserPluginGuest::JavaScriptDialogRequest : public PermissionRequest {
+ public:
+  JavaScriptDialogRequest(const DialogClosedCallback& callback,
+                          BrowserPluginGuest* guest)
+      : callback_(callback),
+        guest_(guest) {
+    RecordAction(
+        UserMetricsAction(
+            "BrowserPlugin.Guest.PermissionRequest.JavaScriptDialog"));
+  }
+
+  virtual void Respond(bool should_allow,
+                       const std::string& user_input) OVERRIDE {
+    if (!guest_)

[lazyboy, 2013/07/19 21:43:16]

How could this turn to null?

[Fady Samuel, 2013/07/23 15:41:10]

Hmm, with the cleanup I recently added for pointer lock it's actually not
possible. Removed.

[Fady Samuel, 2013/07/23 15:41:10]

Hmm, it can't removed.

+      return;
+    callback_.Run(should_allow, UTF8ToUTF16(user_input));
+  }
+  virtual BrowserPluginPermissionType GetType() const OVERRIDE {
+    return BrowserPluginPermissionTypeJavaScriptDialog;
+  }
+
+  virtual ~JavaScriptDialogRequest() {}
+  private:
+   DialogClosedCallback callback_;
+   BrowserPluginGuest* guest_;

[lazyboy, 2013/07/19 21:43:16]

A raw pointer is probably not ok here.

Also what happens if guest ask for dialog, then before embedder decides, guest
somehow gets killed/terminated? 

[Fady Samuel, 2013/07/23 15:41:10]

Removed pointer. This request goes away when BrowserPluginGuest goes away. I
made that change while refactoring pointerlock.

+};
+
 namespace {
 const size_t kNumMaxOutstandingPermissionRequests = 1024;
 
 static std::string WindowOpenDispositionToString(
   WindowOpenDisposition window_open_disposition) {
   switch (window_open_disposition) {
       case IGNORE_ACTION:
         return "ignore";
       case SAVE_TO_DISK:
         return "save_to_disk";
       case CURRENT_TAB:
         return "current_tab";
       case NEW_BACKGROUND_TAB:
         return "new_background_tab";
       case NEW_FOREGROUND_TAB:
         return "new_foreground_tab";
       case NEW_WINDOW:
         return "new_window";
       case NEW_POPUP:
         return "new_popup";
       default:
         NOTREACHED() << "Unknown Window Open Disposition";
         return "ignore";
   }
 }
 
+static std::string JavaScriptMessageTypeToString(
+    JavaScriptMessageType message_type) {
+  switch (message_type) {
+      case JAVASCRIPT_MESSAGE_TYPE_ALERT:
+        return "alert";
+      case JAVASCRIPT_MESSAGE_TYPE_CONFIRM:
+        return "confirm";
+      case JAVASCRIPT_MESSAGE_TYPE_PROMPT:
+        return "prompt";
+      default:
+        NOTREACHED() << "Unknown JavaScript Message Type.";
+        return "unknown";
+  }
+}
+
 // Called on IO thread.
 static std::string RetrieveDownloadURLFromRequestId(
     RenderViewHost* render_view_host,
     int url_request_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   int render_process_id = render_view_host->GetProcess()->GetID();
   GlobalRequestID global_id(render_process_id, url_request_id);
   net::URLRequest* url_request =
       ResourceDispatcherHostImpl::Get()->GetURLRequest(global_id);
@@ skipping 319 matching lines @@
                  permission_request_id));
 }
 
 void BrowserPluginGuest::CloseContents(WebContents* source) {
   if (!delegate_)
     return;
 
   delegate_->Close();
 }
 
+JavaScriptDialogManager* BrowserPluginGuest::GetJavaScriptDialogManager() {
+  return this;
+}
+
 bool BrowserPluginGuest::HandleContextMenu(const ContextMenuParams& params) {
   // TODO(fsamuel): We show the regular page context menu handler for now until
   // we implement the Apps Context Menu API for Browser Plugin (see
   // http://crbug.com/140315).
   return false;  // Will be handled by WebContentsViewGuest.
 }
 
 void BrowserPluginGuest::HandleKeyboardEvent(
     WebContents* source,
     const NativeWebKeyboardEvent& event) {
@@ skipping 707 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,
-    BrowserPluginPermissionType permission_type,
     int request_id,
-    bool should_allow) {
+    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);
+  BrowserPluginPermissionType permission_type = request_itr->second->GetType();
+  request_itr->second->Respond(should_allow, user_input);
 
   // Geolocation requests have to hang around for a while, so we don't delete
   // them here.
   if (permission_type != BrowserPluginPermissionTypeGeolocation) {
     delete request_itr->second;
     permission_request_map_.erase(request_itr);
   }
 }
 
 void BrowserPluginGuest::OnSwapBuffersACK(int instance_id,
@@ skipping 106 matching lines @@
 
   base::DictionaryValue request_info;
   request_info.Set(
       browser_plugin::kURL,
       base::Value::CreateStringValue(request.security_origin.spec()));
   SendMessageToEmbedder(new BrowserPluginMsg_RequestPermission(
       instance_id(), BrowserPluginPermissionTypeMedia,
       request_id, 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,
+    const string16& default_prompt_text,
+    const DialogClosedCallback& callback,
+    bool* did_suppress_message) {
+  if (permission_request_map_.size() >= kNumMaxOutstandingPermissionRequests) {
+    // Cancel the dialog.
+    callback.Run(false, string16());
+    return;
+  }
+  int request_id = next_permission_request_id_++;
+  permission_request_map_[request_id] =
+      new JavaScriptDialogRequest(callback, this);
+  base::DictionaryValue request_info;
+  request_info.Set(
+      browser_plugin::kDefaultPromptText,
+      base::Value::CreateStringValue(UTF16ToUTF8(default_prompt_text)));
+  request_info.Set(
+      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()));
+  SendMessageToEmbedder(new BrowserPluginMsg_RequestPermission(
+      instance_id(), BrowserPluginPermissionTypeJavaScriptDialog,
+      request_id, request_info));
+}
+
+void BrowserPluginGuest::RunBeforeUnloadDialog(
+    WebContents* web_contents,
+    const string16& message_text,
+    bool is_reload,
+    const DialogClosedCallback& callback) {
+  callback.Run(true, string16());

[lazyboy, 2013/07/19 21:43:16]

What does this do? Can you add a comment.

+}
+
+bool BrowserPluginGuest::HandleJavaScriptDialog(
+    WebContents* web_contents,

[lazyboy, 2013/07/19 21:43:16]

nit: can fit in previous line.

[Fady Samuel, 2013/07/23 15:41:10]

The third line cannot.

+    bool accept,
+    const string16* prompt_override) {
+  return false;
+}
+
+void BrowserPluginGuest::ResetJavaScriptState(
+    WebContents* web_contents) {

[lazyboy, 2013/07/19 21:43:16]

nit: can fit in previous line.

[Fady Samuel, 2013/07/23 15:41:10]

Done.

+}
+
 void BrowserPluginGuest::OnUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
 
   BrowserPluginMsg_UpdateRect_Params relay_params;
   relay_params.view_size = params.view_size;
   relay_params.scale_factor = params.scale_factor;
   relay_params.is_resize_ack = ViewHostMsg_UpdateRect_Flags::is_resize_ack(
       params.flags);
   relay_params.needs_ack = params.needs_ack;
 
@@ skipping 40 matching lines @@
 
   SendMessageToEmbedder(
       new BrowserPluginMsg_UpdateRect(instance_id(), relay_params));
 }
 
 void BrowserPluginGuest::DidRetrieveDownloadURLFromRequestId(
     const std::string& request_method,
     int permission_request_id,
     const std::string& url) {
   if (url.empty()) {
-    OnRespondPermission(instance_id(), BrowserPluginPermissionTypeDownload,
-                        permission_request_id, false);
+    OnRespondPermission(instance_id(), permission_request_id,
+        false, std::string());
     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));
 
   SendMessageToEmbedder(
       new BrowserPluginMsg_RequestPermission(instance_id(),
           BrowserPluginPermissionTypeDownload, permission_request_id,
           request_info));
 }
 
 }  // namespace content