Rename PepperPluginDelegateImpl to PepperHelperImpl after getting rid of the PluginDelegate interfa…

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"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "cc/layers/texture_layer.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/pepper/content_decryptor_delegate.h"
 #include "content/renderer/pepper/event_conversion.h"
 #include "content/renderer/pepper/fullscreen_container.h"
 #include "content/renderer/pepper/gfx_conversion.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/message_channel.h"
 #include "content/renderer/pepper/npapi_glue.h"
 #include "content/renderer/pepper/pepper_graphics_2d_host.h"
+#include "content/renderer/pepper/pepper_helper_impl.h"
 #include "content/renderer/pepper/pepper_platform_context_3d.h"
-#include "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #include "content/renderer/pepper/plugin_object.h"
 #include "content/renderer/pepper/ppb_buffer_impl.h"
 #include "content/renderer/pepper/ppb_file_ref_impl.h"
 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "content/renderer/pepper/ppp_pdf.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
 #include "content/renderer/pepper/url_request_info_util.h"
 #include "content/renderer/render_thread_impl.h"
@@ skipping 303 matching lines @@
 
  private:
   PepperPluginInstanceImpl* plugin_;
 };
 
 
 }  // namespace
 
 // static
 PepperPluginInstanceImpl* PepperPluginInstanceImpl::Create(
-    PepperPluginDelegateImpl* delegate,
+    PepperHelperImpl* helper,
     RenderViewImpl* render_view,
     PluginModule* module,
     WebPluginContainer* container,
     const GURL& plugin_url) {
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module);
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined)
     return NULL;
-  return new PepperPluginInstanceImpl(delegate, render_view, module,
+  return new PepperPluginInstanceImpl(helper, render_view, module,
                                       ppp_instance_combined, container,
                                       plugin_url);
 }
 
 PepperPluginInstanceImpl::NaClDocumentLoader::NaClDocumentLoader()
     : finished_loading_(false) {
 }
 
 PepperPluginInstanceImpl::NaClDocumentLoader::~NaClDocumentLoader(){
 }
@@ skipping 29 matching lines @@
   finished_loading_ = true;
 }
 
 void PepperPluginInstanceImpl::NaClDocumentLoader::didFail(
     WebURLLoader* loader,
     const WebURLError& error) {
   DCHECK(!error_.get());
   error_.reset(new WebURLError(error));
 }
 
-PepperPluginInstanceImpl::GamepadImpl::GamepadImpl(
-    PepperPluginDelegateImpl* delegate)
+PepperPluginInstanceImpl::GamepadImpl::GamepadImpl(PepperHelperImpl* helper)
     : Resource(::ppapi::Resource::Untracked()),
-      delegate_(delegate) {
+      helper_(helper) {
 }
 
 PepperPluginInstanceImpl::GamepadImpl::~GamepadImpl() {
 }
 
 PPB_Gamepad_API* PepperPluginInstanceImpl::GamepadImpl::AsPPB_Gamepad_API() {
   return this;
 }
 
 void PepperPluginInstanceImpl::GamepadImpl::Sample(
     PP_Instance instance,
     PP_GamepadsSampleData* data) {
   WebKit::WebGamepads webkit_data;
-  delegate_->SampleGamepads(&webkit_data);
+  helper_->SampleGamepads(&webkit_data);
   ConvertWebKitGamepadData(
       *reinterpret_cast<const ::ppapi::WebKitGamepads*>(&webkit_data), data);
 }
 
 PepperPluginInstanceImpl::PepperPluginInstanceImpl(
-    PepperPluginDelegateImpl* delegate,
+    PepperHelperImpl* helper,
     RenderViewImpl* render_view,
     PluginModule* module,
     ::ppapi::PPP_Instance_Combined* instance_interface,
     WebPluginContainer* container,
     const GURL& plugin_url)
-    : delegate_(delegate),
+    : helper_(helper),
       render_view_(render_view),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(container),
       layer_bound_to_fullscreen_(false),
       plugin_url_(plugin_url),
       full_frame_(false),
       sent_initial_did_change_view_(false),
       view_change_weak_ptr_factory_(this),
       bound_graphics_2d_platform_(NULL),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_input_event_interface_(NULL),
       plugin_messaging_interface_(NULL),
       plugin_mouse_lock_interface_(NULL),
       plugin_pdf_interface_(NULL),
       plugin_private_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_textinput_interface_(NULL),
       plugin_zoom_interface_(NULL),
       checked_for_plugin_input_event_interface_(false),
       checked_for_plugin_messaging_interface_(false),
       checked_for_plugin_pdf_interface_(false),
-      gamepad_impl_(new GamepadImpl(delegate)),
+      gamepad_impl_(new GamepadImpl(helper)),
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
       fullscreen_container_(NULL),
       flash_fullscreen_(false),
       desired_fullscreen_state_(false),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
       selection_caret_(0),
       selection_anchor_(0),
       pending_user_gesture_(0.0),
       document_loader_(NULL),
       nacl_document_load_(false),
       npp_(new NPP_t),
       isolate_(v8::Isolate::GetCurrent()) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
   module_->InstanceCreated(this);
 
-  if (delegate_)
-    delegate_->InstanceCreated(this);
+  if (helper_)
+    helper_->InstanceCreated(this);
 
   if (render_view)  // NULL in tests
     view_data_.is_page_visible = !render_view->is_hidden();
 
   RendererPpapiHostImpl* host_impl = module_->renderer_ppapi_host();
   resource_creation_ = host_impl->CreateInProcessResourceCreationAPI(this);
 
   // TODO(bbudge) remove this when the trusted NaCl plugin has been removed.
   // We must defer certain plugin events for NaCl instances since we switch
   // from the in-process to the out-of-process proxy after instantiating them.
@@ skipping 16 matching lines @@
   // unregister themselves inside the delete call).
   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();
 
-  if (delegate_)
-    delegate_->InstanceDeleted(this);
+  if (helper_)
+    helper_->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 163 matching lines @@
 
 bool PepperPluginInstanceImpl::HandleDocumentLoad(
     const WebKit::WebURLResponse& response) {
   DCHECK(!document_loader_);
   if (!nacl_document_load_) {
     if (module()->is_crashed()) {
       // Don't create a resource for a crashed plugin.
       container()->element().document().frame()->stopLoading();
       return false;
     }
-    delegate_->HandleDocumentLoad(this, response);
+    helper_->HandleDocumentLoad(this, response);
     // If the load was not abandoned, document_loader_ will now be set. It's
     // possible that the load was canceled by now and document_loader_ was
     // already nulled out.
   } else {
     // The NaCl proxy isn't available, so save the response and record document
     // load notifications for later replay.
     nacl_document_response_ = response;
     nacl_document_loader_.reset(new NaClDocumentLoader());
     document_loader_ = nacl_document_loader_.get();
   }
@@ skipping 154 matching lines @@
   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);
+    helper_->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;
@@ skipping 419 matching lines @@
   return !!plugin_zoom_interface_;
 }
 
 bool PepperPluginInstanceImpl::PluginHasFocus() const {
   return flash_fullscreen_ || (has_webkit_focus_ && has_content_area_focus_);
 }
 
 void PepperPluginInstanceImpl::SendFocusChangeNotification() {
   // This call can happen during PepperPluginIn>stanceImpl destruction, because
   // WebKit informs the plugin it's losing focus. See crbug.com/236574
-  if (!delegate_ || !instance_interface_)
+  if (!helper_ || !instance_interface_)
     return;
   bool has_focus = PluginHasFocus();
-  delegate_->PluginFocusChanged(this, has_focus);
+  helper_->PluginFocusChanged(this, has_focus);
   instance_interface_->DidChangeFocus(pp_instance(), PP_FromBool(has_focus));
 }
 
 void PepperPluginInstanceImpl::UpdateTouchEventRequest() {
   bool raw_touch = (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_TOUCH) ||
                    (input_event_mask_ & PP_INPUTEVENT_CLASS_TOUCH);
   container_->requestTouchEventType(raw_touch ?
       WebKit::WebPluginContainer::TouchEventRequestTypeRaw :
       WebKit::WebPluginContainer::TouchEventRequestTypeSynthesizedMouse);
 }
@@ skipping 988 matching lines @@
 void PepperPluginInstanceImpl::UnlockMouse(PP_Instance instance) {
   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);
+  helper_->PluginTextInputTypeChanged(this);
 }
 
 void PepperPluginInstanceImpl::UpdateCaretPosition(
     PP_Instance instance,
     const PP_Rect& caret,
     const PP_Rect& bounding_box) {
   text_input_caret_ = PP_ToGfxRect(caret);
   text_input_caret_bounds_ = PP_ToGfxRect(bounding_box);
   text_input_caret_set_ = true;
-  delegate_->PluginCaretPositionChanged(this);
+  helper_->PluginCaretPositionChanged(this);
 }
 
 void PepperPluginInstanceImpl::CancelCompositionText(PP_Instance instance) {
-  delegate_->PluginRequestedCancelComposition(this);
+  helper_->PluginRequestedCancelComposition(this);
 }
 
 void PepperPluginInstanceImpl::SelectionChanged(PP_Instance instance) {
   // TODO(kinaba): currently the browser always calls RequestSurroundingText.
   // It can be optimized so that it won't call it back until the information
   // is really needed.
 
   // Avoid calling in nested context or else this will reenter the plugin. This
   // uses a weak pointer rather than exploiting the fact that this class is
   // refcounted because we don't actually want this operation to affect the
   // lifetime of the instance.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PepperPluginInstanceImpl::RequestSurroundingText,
                  AsWeakPtr(),
                  static_cast<size_t>(kExtraCharsForTextInput)));
 }
 
 void PepperPluginInstanceImpl::UpdateSurroundingText(PP_Instance instance,
                                                      const char* text,
                                                      uint32_t caret,
                                                      uint32_t anchor) {
   surrounding_text_ = text;
   selection_caret_ = caret;
   selection_anchor_ = anchor;
-  delegate_->PluginSelectionChanged(this);
+  helper_->PluginSelectionChanged(this);
 }
 
 PP_Var PepperPluginInstanceImpl::ResolveRelativeToDocument(
     PP_Instance instance,
     PP_Var relative,
     PP_URLComponents_Dev* components) {
   StringVar* relative_string = StringVar::FromPPVar(relative);
   if (!relative_string)
     return PP_MakeNull();
 
@@ skipping 205 matching lines @@
     base::ProcessId plugin_pid,
     int plugin_child_id) {
   // Create a new module for each instance of the external plugin that is using
   // the IPC based out-of-process proxy. We can't use the existing module,
   // because it is configured for the in-process plugin, and we must keep it
   // that way to allow the page to create other instances.
   scoped_refptr<PluginModule> external_plugin_module(
       module_->CreateModuleForExternalPluginInstance());
 
   RendererPpapiHost* renderer_ppapi_host =
-      delegate_->CreateExternalPluginModule(
+      helper_->CreateExternalPluginModule(
           external_plugin_module,
           file_path,
           permissions,
           channel_handle,
           plugin_pid,
           plugin_child_id);
   if (!renderer_ppapi_host) {
     DLOG(ERROR) << "CreateExternalPluginModule() failed";
     return PP_EXTERNAL_PLUGIN_ERROR_MODULE;
   }
 
   // Finally, switch the instance to the proxy.
   return external_plugin_module->InitAsProxiedExternalPlugin(this);
 }
 
 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);
+    helper_->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 168 matching lines @@
 }
 
 void PepperPluginInstanceImpl::UnSetAndDeleteLockTargetAdapter() {
   if (lock_target_.get()) {
     GetMouseLockDispatcher()->OnLockTargetDestroyed(lock_target_.get());
     lock_target_.reset();
   }
 }
 
 }  // namespace content