BrowserPluginGuest is no longer a WebContentsDelegate

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/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 95 matching lines @@
       auto_size_enabled_(false),
       copy_request_id_(0),
       has_render_view_(has_render_view),
       last_seen_auto_size_enabled_(false),
       is_in_destruction_(false),
       last_text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       last_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       last_can_compose_inline_(true),
       weak_ptr_factory_(this) {
   DCHECK(web_contents);
-  web_contents->SetDelegate(this);
-}
-
-bool BrowserPluginGuest::AddMessageToConsole(WebContents* source,
-                                             int32 level,
-                                             const base::string16& message,
-                                             int32 line_no,
-                                             const base::string16& source_id) {
-  if (!delegate_)
-    return false;
-
-  delegate_->AddMessageToConsole(level, message, line_no, source_id);
-  return true;
 }
 
 void BrowserPluginGuest::WillDestroy(WebContents* web_contents) {
   DCHECK_EQ(web_contents, GetWebContents());
   is_in_destruction_ = true;
 }
 
 base::WeakPtr<BrowserPluginGuest> BrowserPluginGuest::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
@@ skipping 222 matching lines @@
   gfx::Rect guest_rect(bounds);
   guest_rect.Offset(guest_window_rect_.OffsetFromOrigin());
   return guest_rect;
 }
 
 void BrowserPluginGuest::EmbedderVisibilityChanged(bool visible) {
   embedder_visible_ = visible;
   UpdateVisibility();
 }
 
-void BrowserPluginGuest::AddNewContents(WebContents* source,
-                                        WebContents* new_contents,
-                                        WindowOpenDisposition disposition,
-                                        const gfx::Rect& initial_pos,
-                                        bool user_gesture,
-                                        bool* was_blocked) {
-  if (!delegate_)
-    return;
-
-  delegate_->AddNewContents(source, new_contents, disposition,
-                            initial_pos, user_gesture, was_blocked);
-}
-
-void BrowserPluginGuest::CanDownload(
-    RenderViewHost* render_view_host,
-    const GURL& url,
-    const std::string& request_method,
-    const base::Callback<void(bool)>& callback) {
-  if (!delegate_ || !url.is_valid()) {
-    callback.Run(false);
-    return;
-  }
-
-  delegate_->CanDownload(request_method, url, callback);
-}
-
-void BrowserPluginGuest::LoadProgressChanged(WebContents* contents,
-                                             double progress) {
-  if (delegate_)
-    delegate_->LoadProgressed(progress);
-}
-
-void BrowserPluginGuest::CloseContents(WebContents* source) {
-  if (!delegate_)
-    return;
-
-  delegate_->Close();
-}
-
-JavaScriptDialogManager* BrowserPluginGuest::GetJavaScriptDialogManager() {
-  if (!delegate_)
-    return NULL;
-  return delegate_->GetJavaScriptDialogManager();
-}
-
-ColorChooser* BrowserPluginGuest::OpenColorChooser(
-    WebContents* web_contents,
-    SkColor color,
-    const std::vector<ColorSuggestion>& suggestions) {
-  if (!delegate_)
-    return NULL;
-  return delegate_->OpenColorChooser(web_contents, color, suggestions);
-}
-
-bool BrowserPluginGuest::HandleContextMenu(const ContextMenuParams& params) {
-  if (!delegate_)
-    return false;
-
-  return delegate_->HandleContextMenu(params);
-}
-
-void BrowserPluginGuest::HandleKeyboardEvent(
-    WebContents* source,
-    const NativeWebKeyboardEvent& event) {
-  if (!delegate_)
-    return;
-
-  delegate_->HandleKeyboardEvent(event);
-}
-
 void BrowserPluginGuest::SetZoom(double zoom_factor) {
   if (delegate_)
     delegate_->SetZoom(zoom_factor);
 }
 
 void BrowserPluginGuest::PointerLockPermissionResponse(bool allow) {
   SendMessageToEmbedder(
       new BrowserPluginMsg_SetMouseLock(instance_id(), allow));
 }
 
-void BrowserPluginGuest::FindReply(WebContents* contents,
-                                   int request_id,
-                                   int number_of_matches,
-                                   const gfx::Rect& selection_rect,
-                                   int active_match_ordinal,
-                                   bool final_update) {
-  if (!delegate_)
-    return;
-
-  // |selection_rect| is updated to incorporate embedder coordinates.
-  delegate_->FindReply(request_id, number_of_matches,
-                       ToGuestRect(selection_rect),
-                       active_match_ordinal, final_update);
-}
-
-WebContents* BrowserPluginGuest::OpenURLFromTab(WebContents* source,
-                                                const OpenURLParams& params) {
-  if (!delegate_)
-    return NULL;
-  return delegate_->OpenURLFromTab(source, params);
-}
-
-void BrowserPluginGuest::WebContentsCreated(WebContents* source_contents,
-                                            int opener_render_frame_id,
-                                            const base::string16& frame_name,
-                                            const GURL& target_url,
-                                            WebContents* new_contents) {
-  if (!delegate_)
-    return;
-
-  delegate_->WebContentsCreated(source_contents,
-                                opener_render_frame_id,
-                                frame_name,
-                                target_url,
-                                new_contents);
-}
-
-void BrowserPluginGuest::RendererUnresponsive(WebContents* source) {
-  RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Hung"));
-  if (!delegate_)
-    return;
-  delegate_->RendererUnresponsive();
-}
-
-void BrowserPluginGuest::RendererResponsive(WebContents* source) {
-  RecordAction(base::UserMetricsAction("BrowserPlugin.Guest.Responsive"));
-  if (!delegate_)
-    return;
-  delegate_->RendererResponsive();
-}
-
-void BrowserPluginGuest::RunFileChooser(WebContents* web_contents,
-                                        const FileChooserParams& params) {
-  if (!delegate_)
-    return;
-  delegate_->RunFileChooser(web_contents, params);
-}
-
-bool BrowserPluginGuest::ShouldFocusPageAfterCrash() {
-  // Rather than managing focus in WebContentsImpl::RenderViewReady, we will
-  // manage the focus ourselves.
-  return false;
-}
-
 WebContentsImpl* BrowserPluginGuest::GetWebContents() const {
   return static_cast<WebContentsImpl*>(web_contents());
 }
 
 gfx::Point BrowserPluginGuest::GetScreenCoordinates(
     const gfx::Point& relative_position) const {
   gfx::Point screen_pos(relative_position);
   screen_pos += guest_window_rect_.OffsetFromOrigin();
   return screen_pos;
 }
@@ skipping 542 matching lines @@
 void BrowserPluginGuest::OnShowWidget(int route_id,
                                       const gfx::Rect& initial_pos) {
   GetWebContents()->ShowCreatedWidget(route_id, initial_pos);
 }
 
 void BrowserPluginGuest::OnTakeFocus(bool reverse) {
   SendMessageToEmbedder(
       new BrowserPluginMsg_AdvanceFocus(instance_id(), reverse));
 }
 
-void BrowserPluginGuest::RequestMediaAccessPermission(
-    WebContents* web_contents,
-    const MediaStreamRequest& request,
-    const MediaResponseCallback& callback) {
-  if (!delegate_) {
-    callback.Run(MediaStreamDevices(),
-                 MEDIA_DEVICE_INVALID_STATE,
-                 scoped_ptr<MediaStreamUI>());
-    return;
-  }
-
-  delegate_->RequestMediaAccessPermission(request, callback);
-}
-
-bool BrowserPluginGuest::PreHandleGestureEvent(
-    WebContents* source, const blink::WebGestureEvent& event) {
-  if (!delegate_)
-    return false;
-
-  return delegate_->PreHandleGestureEvent(source, event);
-}
-
 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);
 
   bool size_changed = last_seen_view_size_ != params.view_size;
   gfx::Size old_size = last_seen_view_size_;
@@ skipping 31 matching lines @@
 void BrowserPluginGuest::OnImeCompositionRangeChanged(
       const gfx::Range& range,
       const std::vector<gfx::Rect>& character_bounds) {
   static_cast<RenderWidgetHostViewBase*>(
       web_contents()->GetRenderWidgetHostView())->ImeCompositionRangeChanged(
           range, character_bounds);
 }
 #endif
 
 }  // namespace content