Remove more methods from PluginDelegate. Some I moved the implementationto the callers. For others,…

content/renderer/pepper/pepper_plugin_instance_impl.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/renderer/pepper/pepper_plugin_instance_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 306 matching lines @@
 // returned vector are only guaranteed valid so long as the vector of strings
 // is not modified.
 scoped_ptr<const char*[]> StringVectorToArgArray(
     const std::vector<std::string>& vector) {
   scoped_ptr<const char*[]> array(new const char*[vector.size()]);
   for (size_t i = 0; i < vector.size(); ++i)
     array[i] = vector[i].c_str();
   return array.Pass();
 }
 
+class PluginInstanceLockTarget : public MouseLockDispatcher::LockTarget {
+ public:
+  PluginInstanceLockTarget(PepperPluginInstanceImpl* plugin)
+      : plugin_(plugin) {}
+
+  virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
+    plugin_->OnLockMouseACK(succeeded);
+  }
+
+  virtual void OnMouseLockLost() OVERRIDE {
+    plugin_->OnMouseLockLost();
+  }
+
+  virtual bool HandleMouseLockedInputEvent(
+      const WebKit::WebMouseEvent &event) OVERRIDE {
+    plugin_->HandleMouseLockedInputEvent(event);
+    return true;
+  }
+
+ private:
+  PepperPluginInstanceImpl* plugin_;
+};
+
+
 }  // namespace
 
 // static
 PepperPluginInstanceImpl* PepperPluginInstanceImpl::Create(
     PluginDelegate* delegate,
     RenderViewImpl* render_view,
     PluginModule* module,
     WebPluginContainer* container,
     const GURL& plugin_url) {
   base::Callback<const void*(const char*)> get_plugin_interface_func =
@@ skipping 164 matching lines @@
   PluginObjectSet plugin_object_copy;
   live_plugin_objects_.swap(plugin_object_copy);
   for (PluginObjectSet::iterator i = plugin_object_copy.begin();
        i != plugin_object_copy.end(); ++i)
     delete *i;
 
   if (TrackedCallback::IsPending(lock_mouse_callback_))
     lock_mouse_callback_->Abort();
 
   delegate_->InstanceDeleted(this);
+  UnSetAndDeleteLockTargetAdapter();
   module_->InstanceDeleted(this);
   // If we switched from the NaCl plugin module, notify it too.
   if (original_module_.get())
     original_module_->InstanceDeleted(this);
 
   // This should be last since some of the above "instance deleted" calls will
   // want to look up in the global map to get info off of our object.
   HostGlobals::Get()->InstanceDeleted(pp_instance_);
 }
 
@@ skipping 91 matching lines @@
   // Force free all resources and vars.
   HostGlobals::Get()->InstanceCrashed(pp_instance());
 
   // Free any associated graphics.
   SetFullscreen(false);
   FlashSetFullscreen(false, false);
   // Unbind current 2D or 3D graphics context.
   BindGraphics(pp_instance(), 0);
   InvalidateRect(gfx::Rect());
 
-  delegate()->PluginCrashed(this);
+  render_view_->PluginCrashed(module_->path(), module_->GetPeerProcessId());
+  UnSetAndDeleteLockTargetAdapter();
 }
 
 static void SetGPUHistogram(const ::ppapi::Preferences& prefs,
                             const std::vector<std::string>& arg_names,
                             const std::vector<std::string>& arg_values) {
   // Calculate a histogram to let us determine how likely people are to try to
   // run Stage3D content on machines that have it blacklisted.
 #if defined(OS_WIN)
   bool needs_gpu = false;
   bool is_xp = base::win::GetVersion() <= base::win::VERSION_XP;
@@ skipping 223 matching lines @@
   gfx::Rect caret(text_input_caret_);
   caret.Offset(view_data_.rect.point.x, view_data_.rect.point.y);
   return caret;
 }
 
 bool PepperPluginInstanceImpl::HandleInputEvent(
     const WebKit::WebInputEvent& event,
     WebCursorInfo* cursor_info) {
   TRACE_EVENT0("ppapi", "PepperPluginInstanceImpl::HandleInputEvent");
 
-  if (WebInputEvent::isMouseEventType(event.type))
-    delegate()->DidReceiveMouseEvent(this);
+  if (WebInputEvent::isMouseEventType(event.type)) {
+    static_cast<PepperPluginDelegateImpl*>(delegate_)->DidReceiveMouseEvent(
+        this);
+  }
 
   // Don't dispatch input events to crashed plugins.
   if (module()->is_crashed())
     return false;
 
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PepperPluginInstanceImpl> ref(this);
 
   bool rv = false;
   if (LoadInputEventInterface()) {
@@ skipping 701 matching lines @@
       lock_mouse_callback_->Run(PP_ERROR_FAILED);
     return;
   }
 
   PPB_Graphics3D_Impl* graphics_3d  = bound_graphics_3d_.get();
   if (graphics_3d)
     UpdateLayer();
 
   bool old_plugin_focus = PluginHasFocus();
   flash_fullscreen_ = flash_fullscreen;
-  if (is_mouselock_pending && !delegate()->IsMouseLocked(this)) {
+  if (is_mouselock_pending && !IsMouseLocked()) {
     if (!IsProcessingUserGesture() &&
         !module_->permissions().HasPermission(
             ::ppapi::PERMISSION_BYPASS_USER_GESTURE)) {
       lock_mouse_callback_->Run(PP_ERROR_NO_USER_GESTURE);
     } else {
       // Open a user gesture here so the Webkit user gesture checks will succeed
       // for out-of-process plugins.
       WebScopedUserGesture user_gesture(CurrentUserGestureToken());
-      if (!delegate()->LockMouse(this))
+      if (!LockMouse())
         lock_mouse_callback_->Run(PP_ERROR_FAILED);
     }
   }
 
   if (PluginHasFocus() != old_plugin_focus)
     SendFocusChangeNotification();
 }
 
 bool PepperPluginInstanceImpl::IsViewAccelerated() {
   if (!container_)
@@ skipping 665 matching lines @@
   DoSetCursor(custom_cursor.release());
   return PP_TRUE;
 }
 
 int32_t PepperPluginInstanceImpl::LockMouse(
     PP_Instance instance,
     scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(lock_mouse_callback_))
     return PP_ERROR_INPROGRESS;
 
-  if (delegate()->IsMouseLocked(this))
+  if (IsMouseLocked())
     return PP_OK;
 
   if (!CanAccessMainFrame())
     return PP_ERROR_NOACCESS;
 
   if (!IsProcessingUserGesture())
     return PP_ERROR_NO_USER_GESTURE;
 
   // Attempt mouselock only if Flash isn't waiting on fullscreen, otherwise
   // we wait and call LockMouse() in UpdateFlashFullscreenState().
-  if (!FlashIsFullscreenOrPending() || flash_fullscreen()) {
+  if (!FlashIsFullscreenOrPending() || flash_fullscreen_) {
     // Open a user gesture here so the Webkit user gesture checks will succeed
     // for out-of-process plugins.
     WebScopedUserGesture user_gesture(CurrentUserGestureToken());
-    if (!delegate()->LockMouse(this))
+    if (!LockMouse())
       return PP_ERROR_FAILED;
   }
 
   // Either mouselock succeeded or a Flash fullscreen is pending.
   lock_mouse_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PepperPluginInstanceImpl::UnlockMouse(PP_Instance instance) {
-  delegate()->UnlockMouse(this);
+  GetMouseLockDispatcher()->UnlockMouse(GetOrCreateLockTargetAdapter());
 }
 
 void PepperPluginInstanceImpl::SetTextInputType(PP_Instance instance,
                                                 PP_TextInput_Type type) {
   int itype = type;
   if (itype < 0 || itype > ui::TEXT_INPUT_TYPE_URL)
     itype = ui::TEXT_INPUT_TYPE_NONE;
   text_input_type_ = static_cast<ui::TextInputType>(itype);
   delegate()->PluginTextInputTypeChanged(this);
 }
@@ skipping 279 matching lines @@
 
 void PepperPluginInstanceImpl::SetAlwaysOnTop(bool on_top) {
   always_on_top_ = on_top;
 }
 
 void PepperPluginInstanceImpl::DoSetCursor(WebCursorInfo* cursor) {
   cursor_.reset(cursor);
   if (fullscreen_container_) {
     fullscreen_container_->DidChangeCursor(*cursor);
   } else {
-    delegate()->DidChangeCursor(this, *cursor);
+    static_cast<PepperPluginDelegateImpl*>(delegate_)->DidChangeCursor(
+        this, *cursor);
   }
 }
 
 bool PepperPluginInstanceImpl::IsFullPagePlugin() {
   WebFrame* frame = container()->element().document().frame();
   return frame->view()->mainFrame()->document().isPluginDocument();
 }
 
 void PepperPluginInstanceImpl::FlashSetFullscreen(bool fullscreen,
                                                   bool delay_report) {
@@ skipping 133 matching lines @@
 
 void PepperPluginInstanceImpl::ResetSizeAttributesAfterFullscreen() {
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
+bool PepperPluginInstanceImpl::IsMouseLocked() {
+  return GetMouseLockDispatcher()->IsMouseLockedTo(
+      GetOrCreateLockTargetAdapter());
+}
+
+bool PepperPluginInstanceImpl::LockMouse() {
+  return GetMouseLockDispatcher()->LockMouse(GetOrCreateLockTargetAdapter());
+}
+
+MouseLockDispatcher::LockTarget*
+    PepperPluginInstanceImpl::GetOrCreateLockTargetAdapter() {
+  if (!lock_target_.get()) {
+    lock_target_.reset(new PluginInstanceLockTarget(this));
+  }
+  return lock_target_.get();
+}
+
+MouseLockDispatcher* PepperPluginInstanceImpl::GetMouseLockDispatcher() {
+  if (flash_fullscreen_) {
+    RenderWidgetFullscreenPepper* container =
+        static_cast<RenderWidgetFullscreenPepper*>(fullscreen_container_);
+    return container->mouse_lock_dispatcher();
+  } else {
+    return render_view_->mouse_lock_dispatcher();
+  }
+}
+
+void PepperPluginInstanceImpl::UnSetAndDeleteLockTargetAdapter() {
+  if (lock_target_.get()) {
+    GetMouseLockDispatcher()->OnLockTargetDestroyed(lock_target_.get());
+    lock_target_.reset();
+  }
+}
+
 }  // namespace content