BrowserPluginGuest is no longer a WebContentsDelegate

chrome/browser/guest_view/web_view/web_view_guest.cc

 // Copyright 2014 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/guest_view/web_view/web_view_guest.h"
 
 #include "base/debug/stack_trace.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 337 matching lines @@
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   scoped_ptr<base::ListValue> items =
       MenuModelToValue(pending_menu_->menu_model());
   args->Set(webview::kContextMenuItems, items.release());
   args->SetInteger(webview::kRequestId, request_id);
   DispatchEvent(new GuestViewBase::Event(webview::kEventContextMenu,
                                          args.Pass()));
   return true;
 }
 
-void WebViewGuest::AddMessageToConsole(int32 level,
+bool WebViewGuest::AddMessageToConsole(WebContents* source,
+                                       int32 level,
                                        const base::string16& message,
                                        int32 line_no,
                                        const base::string16& source_id) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   // Log levels are from base/logging.h: LogSeverity.
   args->SetInteger(webview::kLevel, level);
   args->SetString(webview::kMessage, message);
   args->SetInteger(webview::kLine, line_no);
   args->SetString(webview::kSourceId, source_id);
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventConsoleMessage, args.Pass()));
+  return true;
 }
 
-void WebViewGuest::Close() {
+void WebViewGuest::CloseContents(WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   DispatchEvent(new GuestViewBase::Event(webview::kEventClose, args.Pass()));
 }
 
 void WebViewGuest::DidAttach() {
   if (GetOpener()) {
     // We need to do a navigation here if the target URL has changed between
     // the time the WebContents was created and the time it was attached.
     // We also need to do an initial navigation if a RenderView was never
     // created for the new window in cases where there is no referrer.
@@ skipping 28 matching lines @@
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &RemoveWebViewEventListenersOnIOThread,
           browser_context(), embedder_extension_id(),
           embedder_render_process_id(),
           view_instance_id()));
 }
 
-void WebViewGuest::FindReply(int request_id,
+void WebViewGuest::FindReply(WebContents* source,
+                             int request_id,
                              int number_of_matches,
                              const gfx::Rect& selection_rect,
                              int active_match_ordinal,
                              bool final_update) {
   find_helper_.FindReply(request_id, number_of_matches, selection_rect,
                          active_match_ordinal, final_update);
 }
 
 void WebViewGuest::GuestProcessGone(base::TerminationStatus status) {
   // Cancel all find sessions in progress.
   find_helper_.CancelAllFindSessions();
 
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
                    guest_web_contents()->GetRenderProcessHost()->GetID());
   args->SetString(webview::kReason, TerminationStatusToString(status));
   DispatchEvent(new GuestViewBase::Event(webview::kEventExit, args.Pass()));
 }
 
 void WebViewGuest::HandleKeyboardEvent(
+    WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   if (!attached())
     return;
 
   if (HandleKeyboardShortcuts(event))
     return;
 
   // Send the unhandled keyboard events back to the embedder to reprocess them.
   // TODO(fsamuel): This introduces the possibility of out-of-order keyboard
   // events because the guest may be arbitrarily delayed when responding to
   // keyboard events. In that time, the embedder may have received and processed
   // additional key events. This needs to be fixed as soon as possible.
   // See http://crbug.com/229882.
   embedder_web_contents()->GetDelegate()->HandleKeyboardEvent(
       web_contents(), event);
 }
 
 bool WebViewGuest::IsDragAndDropEnabled() {
   return true;
 }
 
-void WebViewGuest::LoadProgressed(double progress) {
+void WebViewGuest::LoadProgressChanged(content::WebContents* source,
+                                       double progress) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetString(guestview::kUrl, guest_web_contents()->GetURL().spec());
   args->SetDouble(webview::kProgress, progress);
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventLoadProgress, args.Pass()));
 }
 
 void WebViewGuest::LoadAbort(bool is_top_level,
                              const GURL& url,
                              const std::string& error_type) {
@@ skipping 11 matching lines @@
     return;
 
   if (name_ == name)
     return;
 
   ReportFrameNameChange(name);
 }
 
 WebViewGuest* WebViewGuest::CreateNewGuestWindow(
     const content::OpenURLParams& params) {
-
   GuestViewManager* guest_manager =
       GuestViewManager::FromBrowserContext(browser_context());
   // Allocate a new instance ID for the new guest.
   int instance_id = guest_manager->GetNextInstanceID();
 
   // Set the attach params to use the same partition as the opener.
   // We pull the partition information from the site's URL, which is of the
   // form guest://site/{persist}?{partition_name}.
   const GURL& site_url = guest_web_contents()->GetSiteInstance()->GetSiteURL();
 
@@ skipping 18 matching lines @@
   // Request permission to show the new window.
   RequestNewWindowPermission(params.disposition, gfx::Rect(),
                              params.user_gesture,
                              new_guest->guest_web_contents());
 
   return new_guest;
 }
 
 // TODO(fsamuel): Find a reliable way to test the 'responsive' and
 // 'unresponsive' events.
-void WebViewGuest::RendererResponsive() {
+void WebViewGuest::RendererResponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventResponsive, args.Pass()));
 }
 
-void WebViewGuest::RendererUnresponsive() {
+void WebViewGuest::RendererUnresponsive(content::WebContents* source) {
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kProcessId,
       guest_web_contents()->GetRenderProcessHost()->GetID());
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventUnresponsive, args.Pass()));
 }
 
 void WebViewGuest::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
@@ skipping 419 matching lines @@
   scoped_ptr<base::DictionaryValue> args(new base::DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
   DispatchEvent(
       new GuestViewBase::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 void WebViewGuest::RequestMediaAccessPermission(
+    content::WebContents* source,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   base::DictionaryValue request_info;
   request_info.Set(
       guestview::kUrl,
       base::Value::CreateStringValue(request.security_origin.spec()));
   RequestPermission(WEB_VIEW_PERMISSION_TYPE_MEDIA,
                     request_info,
                     base::Bind(&WebViewGuest::OnWebViewMediaPermissionResponse,
                                base::Unretained(this),
                                request,
                                callback),
                     false /* allowed_by_default */);
 }
 
 void WebViewGuest::CanDownload(
+    content::RenderViewHost* render_view_host,
+    const GURL& url,
     const std::string& request_method,
-    const GURL& url,
     const base::Callback<void(bool)>& callback) {
   base::DictionaryValue request_info;
   request_info.Set(
       guestview::kUrl,
       base::Value::CreateStringValue(url.spec()));
   RequestPermission(
       WEB_VIEW_PERMISSION_TYPE_DOWNLOAD,
       request_info,
       base::Bind(&WebViewGuest::OnWebViewDownloadPermissionResponse,
                  base::Unretained(this),
@@ skipping 394 matching lines @@
     bool allow,
     const std::string& user_input) {
   WebViewGuest* guest =
       WebViewGuest::From(embedder_render_process_id(), new_window_instance_id);
   if (!guest)
     return;
 
   if (!allow)
     guest->Destroy();
 }