Remove PluginDelegate completely. In a followup I'll rename PepperPluginDelegateImpl to something c…

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 334 matching lines @@
 
  private:
   PepperPluginInstanceImpl* plugin_;
 };
 
 
 }  // namespace
 
 // static
 PepperPluginInstanceImpl* PepperPluginInstanceImpl::Create(
-    PluginDelegate* delegate,
+    PepperPluginDelegateImpl* delegate,
     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;
@@ skipping 40 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(PluginDelegate* delegate)
+PepperPluginInstanceImpl::GamepadImpl::GamepadImpl(
+    PepperPluginDelegateImpl* delegate)
     : Resource(::ppapi::Resource::Untracked()),
       delegate_(delegate) {
 }
 
 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);
   ConvertWebKitGamepadData(
       *reinterpret_cast<const ::ppapi::WebKitGamepads*>(&webkit_data), data);
 }
 
 PepperPluginInstanceImpl::PepperPluginInstanceImpl(
-    PluginDelegate* delegate,
+    PepperPluginDelegateImpl* delegate,
     RenderViewImpl* render_view,
     PluginModule* module,
     ::ppapi::PPP_Instance_Combined* instance_interface,
     WebPluginContainer* container,
     const GURL& plugin_url)
     : delegate_(delegate),
       render_view_(render_view),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
@@ skipping 36 matching lines @@
       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_));
-  DCHECK(delegate);
   module_->InstanceCreated(this);
-  delegate_->InstanceCreated(this);
+
+  if (delegate_)
+    delegate_->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();
 
-  delegate_->InstanceDeleted(this);
+  if (delegate_)
+    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 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);
+    delegate_->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)) {
-    static_cast<PepperPluginDelegateImpl*>(delegate_)->DidReceiveMouseEvent(
-        this);
+    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;
@@ skipping 417 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 PepperPluginInstanceImpl destruction, because
+  // 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_)
     return;
   bool has_focus = PluginHasFocus();
-  delegate()->PluginFocusChanged(this, has_focus);
+  delegate_->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);
+  delegate_->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);
+  delegate_->PluginCaretPositionChanged(this);
 }
 
 void PepperPluginInstanceImpl::CancelCompositionText(PP_Instance instance) {
-  delegate()->PluginRequestedCancelComposition(this);
+  delegate_->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);
+  delegate_->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 230 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 {
-    static_cast<PepperPluginDelegateImpl*>(delegate_)->DidChangeCursor(
-        this, *cursor);
+    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 168 matching lines @@
 }
 
 void PepperPluginInstanceImpl::UnSetAndDeleteLockTargetAdapter() {
   if (lock_target_.get()) {
     GetMouseLockDispatcher()->OnLockTargetDestroyed(lock_target_.get());
     lock_target_.reset();
   }
 }
 
 }  // namespace content