Create a public API around webkit::ppapi::PluginInstance and use it in chrome. After this, webkit/p…

webkit/plugins/ppapi/ppapi_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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/ppapi_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"
@@ skipping 270 matching lines @@
     PP_PRINTSCALINGOPTION_FIT_TO_PRINTABLE_AREA);
 COMPILE_ASSERT_PRINT_SCALING_MATCHING_ENUM(
     WebKit::WebPrintScalingOptionSourceSize, PP_PRINTSCALINGOPTION_SOURCE_SIZE);
 
 // Sets |*security_origin| to be the WebKit security origin associated with the
 // document containing the given plugin instance. On success, returns true. If
 // the instance is invalid, returns false and |*security_origin| will be
 // unchanged.
 bool SecurityOriginForInstance(PP_Instance instance_id,
                                WebKit::WebSecurityOrigin* security_origin) {
-  PluginInstance* instance = HostGlobals::Get()->GetInstance(instance_id);
+  PluginInstanceImpl* instance = HostGlobals::Get()->GetInstance(instance_id);
   if (!instance)
     return false;
 
   WebElement plugin_element = instance->container()->element();
   *security_origin = plugin_element.document().securityOrigin();
   return true;
 }
 
 // Convert the given vector to an array of C-strings. The strings in the
 // 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();
 }
 
 }  // namespace
 
 // static
-PluginInstance* PluginInstance::Create(PluginDelegate* delegate,
-                                       content::RenderView* render_view,
-                                       PluginModule* module,
-                                       WebPluginContainer* container,
-                                       const GURL& plugin_url) {
+PluginInstanceImpl* PluginInstanceImpl::Create(PluginDelegate* delegate,
+                                               content::RenderView* 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 PluginInstance(delegate, render_view, module,
-                            ppp_instance_combined, container, plugin_url);
+  return new PluginInstanceImpl(delegate, render_view, module,
+                                ppp_instance_combined, container, plugin_url);
 }
 
-PluginInstance::NaClDocumentLoader::NaClDocumentLoader()
+PluginInstanceImpl::NaClDocumentLoader::NaClDocumentLoader()
     : finished_loading_(false) {
 }
 
-PluginInstance::NaClDocumentLoader::~NaClDocumentLoader(){
+PluginInstanceImpl::NaClDocumentLoader::~NaClDocumentLoader(){
 }
 
-void PluginInstance::NaClDocumentLoader::ReplayReceivedData(
+void PluginInstanceImpl::NaClDocumentLoader::ReplayReceivedData(
     WebURLLoaderClient* document_loader) {
   for (std::list<std::string>::iterator it = data_.begin();
        it != data_.end(); ++it) {
     document_loader->didReceiveData(NULL, it->c_str(), it->length(),
                                     0 /* encoded_data_length */);
   }
   if (finished_loading_) {
     document_loader->didFinishLoading(NULL,
                                       0 /* finish_time */);
   }
   if (error_.get()) {
     document_loader->didFail(NULL, *error_);
   }
 }
 
-void PluginInstance::NaClDocumentLoader::didReceiveData(
+void PluginInstanceImpl::NaClDocumentLoader::didReceiveData(
     WebURLLoader* loader,
     const char* data,
     int data_length,
     int encoded_data_length) {
   data_.push_back(std::string(data, data_length));
 }
 
-void PluginInstance::NaClDocumentLoader::didFinishLoading(
+void PluginInstanceImpl::NaClDocumentLoader::didFinishLoading(
     WebURLLoader* loader,
     double finish_time) {
   DCHECK(!finished_loading_);
   finished_loading_ = true;
 }
 
-void PluginInstance::NaClDocumentLoader::didFail(
+void PluginInstanceImpl::NaClDocumentLoader::didFail(
     WebURLLoader* loader,
     const WebURLError& error) {
   DCHECK(!error_.get());
   error_.reset(new WebURLError(error));
 }
 
-PluginInstance::GamepadImpl::GamepadImpl(PluginDelegate* delegate)
+PluginInstanceImpl::GamepadImpl::GamepadImpl(PluginDelegate* delegate)
     : Resource(::ppapi::Resource::Untracked()),
       delegate_(delegate) {
 }
 
-PPB_Gamepad_API* PluginInstance::GamepadImpl::AsPPB_Gamepad_API() {
+PPB_Gamepad_API* PluginInstanceImpl::GamepadImpl::AsPPB_Gamepad_API() {
   return this;
 }
 
-void PluginInstance::GamepadImpl::Sample(PP_Instance /* instance */,
-                                         PP_GamepadsSampleData* data) {
+void PluginInstanceImpl::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);
 }
 
-PluginInstance::PluginInstance(
+PluginInstanceImpl::PluginInstanceImpl(
     PluginDelegate* delegate,
     content::RenderView* 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),
@@ skipping 51 matching lines @@
   view_data_.is_page_visible = delegate->IsPageVisible();
   resource_creation_ = delegate_->CreateResourceCreationAPI(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.
   if (module->name() == "Native Client")
     nacl_document_load_ = true;
 }
 
-PluginInstance::~PluginInstance() {
+PluginInstanceImpl::~PluginInstanceImpl() {
   DCHECK(!fullscreen_container_);
 
   // Force-unbind any Graphics. In the case of Graphics2D, if the plugin
   // leaks the graphics 2D, it may actually get cleaned up after our
   // destruction, so we need its pointers to be up-to-date.
   BindGraphics(pp_instance(), 0);
 
   // Free all the plugin objects. This will automatically clear the back-
   // pointer from the NPObject so WebKit can't call into the plugin any more.
   //
@@ skipping 18 matching lines @@
   // want to look up in the global map to get info off of our object.
   HostGlobals::Get()->InstanceDeleted(pp_instance_);
 }
 
 // NOTE: Any of these methods that calls into the plugin needs to take into
 // account that the plugin may use Var to remove the <embed> from the DOM, which
 // will make the WebPluginImpl drop its reference, usually the last one. If a
 // method needs to access a member of the instance after the call has returned,
 // then it needs to keep its own reference on the stack.
 
-void PluginInstance::Delete() {
+void PluginInstanceImpl::Delete() {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   // Force the MessageChannel to release its "passthrough object" which should
   // release our last reference to the "InstanceObject" and will probably
   // destroy it. We want to do this prior to calling DidDestroy in case the
   // destructor of the instance object tries to use the instance.
   message_channel_->SetPassthroughObject(NULL);
   // If this is a NaCl plugin instance, shut down the NaCl plugin by calling
   // its DidDestroy. Don't call DidDestroy on the untrusted plugin instance,
   // since there is little that it can do at this point.
   if (original_instance_interface_)
     original_instance_interface_->DidDestroy(pp_instance());
   else
     instance_interface_->DidDestroy(pp_instance());
   // Ensure we don't attempt to call functions on the destroyed instance.
   original_instance_interface_.reset();
   instance_interface_.reset();
 
   if (fullscreen_container_) {
     fullscreen_container_->Destroy();
     fullscreen_container_ = NULL;
   }
   bound_graphics_3d_ = NULL;
   UpdateLayer();
   container_ = NULL;
 }
 
-void PluginInstance::Paint(WebCanvas* canvas,
-                           const gfx::Rect& plugin_rect,
-                           const gfx::Rect& paint_rect) {
+void PluginInstanceImpl::Paint(WebCanvas* canvas,
+                               const gfx::Rect& plugin_rect,
+                               const gfx::Rect& paint_rect) {
   TRACE_EVENT0("ppapi", "PluginInstance::Paint");
   if (module()->is_crashed()) {
     // Crashed plugin painting.
     if (!sad_plugin_)  // Lazily initialize bitmap.
       sad_plugin_ = delegate_->GetSadPluginBitmap();
     if (sad_plugin_)
       webkit::PaintSadPlugin(canvas, plugin_rect, *sad_plugin_);
     return;
   }
 
   PluginDelegate::PlatformGraphics2D* bound_graphics_2d = GetBoundGraphics2D();
   if (bound_graphics_2d)
     bound_graphics_2d->Paint(canvas, plugin_rect, paint_rect);
 }
 
-void PluginInstance::InvalidateRect(const gfx::Rect& rect) {
+void PluginInstanceImpl::InvalidateRect(const gfx::Rect& rect) {
   if (fullscreen_container_) {
     if (rect.IsEmpty())
       fullscreen_container_->Invalidate();
     else
       fullscreen_container_->InvalidateRect(rect);
   } else {
     if (!container_ ||
         view_data_.rect.size.width == 0 || view_data_.rect.size.height == 0)
       return;  // Nothing to do.
     if (rect.IsEmpty())
       container_->invalidate();
     else
       container_->invalidateRect(rect);
   }
 }
 
-void PluginInstance::ScrollRect(int dx, int dy, const gfx::Rect& rect) {
+void PluginInstanceImpl::ScrollRect(int dx, int dy, const gfx::Rect& rect) {
   if (fullscreen_container_) {
     fullscreen_container_->ScrollRect(dx, dy, rect);
   } else {
     if (full_frame_ && !IsViewAccelerated()) {
       container_->scrollRect(dx, dy, rect);
     } else {
       // Can't do optimized scrolling since there could be other elements on top
       // of us or the view renders via the accelerated compositor which is
       // incompatible with the move and backfill scrolling model.
       InvalidateRect(rect);
     }
   }
 }
 
-void PluginInstance::CommitBackingTexture() {
+void PluginInstanceImpl::CommitBackingTexture() {
   if (texture_layer_.get())
     texture_layer_->SetNeedsDisplay();
 }
 
-void PluginInstance::InstanceCrashed() {
+void PluginInstanceImpl::InstanceCrashed() {
   // 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());
 
@@ skipping 24 matching lines @@
   // 3 : 3D content and GPU is not blacklisted
   // 4 : No 3D content and GPU is blacklisted on XP
   // 5 : No 3D content and GPU is not blacklisted on XP
   // 6 : 3D content but GPU is blacklisted on XP
   // 7 : 3D content and GPU is not blacklisted on XP
   UMA_HISTOGRAM_ENUMERATION("Flash.UsesGPU",
       is_xp * 4 + needs_gpu * 2 + prefs.is_webgl_supported, 8);
 #endif
 }
 
-bool PluginInstance::Initialize(const std::vector<std::string>& arg_names,
-                                const std::vector<std::string>& arg_values,
-                                bool full_frame) {
+bool PluginInstanceImpl::Initialize(const std::vector<std::string>& arg_names,
+                                    const std::vector<std::string>& arg_values,
+                                    bool full_frame) {
   message_channel_.reset(new MessageChannel(this));
 
   full_frame_ = full_frame;
 
   UpdateTouchEventRequest();
   container_->setWantsWheelEvents(IsAcceptingWheelEvents());
 
   SetGPUHistogram(delegate_->GetPreferences(), arg_names, arg_values);
 
   argn_ = arg_names;
   argv_ = arg_values;
   scoped_ptr<const char*[]> argn_array(StringVectorToArgArray(argn_));
   scoped_ptr<const char*[]> argv_array(StringVectorToArgArray(argv_));
   bool success =  PP_ToBool(instance_interface_->DidCreate(pp_instance(),
                                                            argn_.size(),
                                                            argn_array.get(),
                                                            argv_array.get()));
   if (success)
     message_channel_->StopQueueingJavaScriptMessages();
   return success;
 }
 
-bool PluginInstance::HandleDocumentLoad(
+bool PluginInstanceImpl::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);
     // 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();
   }
   return true;
 }
 
-bool PluginInstance::SendCompositionEventToPlugin(PP_InputEvent_Type type,
-                                                  const base::string16& text) {
+bool PluginInstanceImpl::SendCompositionEventToPlugin(
+    PP_InputEvent_Type type, const base::string16& text) {
   std::vector<WebKit::WebCompositionUnderline> empty;
   return SendCompositionEventWithUnderlineInformationToPlugin(
       type, text, empty, static_cast<int>(text.size()),
       static_cast<int>(text.size()));
 }
 
-bool PluginInstance::SendCompositionEventWithUnderlineInformationToPlugin(
+bool PluginInstanceImpl::SendCompositionEventWithUnderlineInformationToPlugin(
     PP_InputEvent_Type type,
     const base::string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
 
   if (!LoadInputEventInterface())
     return false;
 
   PP_InputEvent_Class event_class = PP_INPUTEVENT_CLASS_IME;
   if (!(filtered_input_event_mask_ & event_class) &&
       !(input_event_mask_ & event_class))
     return false;
 
   ::ppapi::InputEventData event;
@@ skipping 48 matching lines @@
     event.is_filtered = true;
   else
     handled = true;  // Unfiltered events are assumed to be handled.
   scoped_refptr<PPB_InputEvent_Shared> event_resource(
       new PPB_InputEvent_Shared(::ppapi::OBJECT_IS_IMPL, pp_instance(), event));
   handled |= PP_ToBool(plugin_input_event_interface_->HandleInputEvent(
       pp_instance(), event_resource->pp_resource()));
   return handled;
 }
 
-void PluginInstance::RequestInputEventsHelper(uint32_t event_classes) {
+void PluginInstanceImpl::RequestInputEventsHelper(uint32_t event_classes) {
   if (event_classes & PP_INPUTEVENT_CLASS_TOUCH)
     UpdateTouchEventRequest();
   if (event_classes & PP_INPUTEVENT_CLASS_WHEEL)
     container_->setWantsWheelEvents(IsAcceptingWheelEvents());
 }
 
-bool PluginInstance::HandleCompositionStart(const base::string16& text) {
+bool PluginInstanceImpl::HandleCompositionStart(const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_START,
                                       text);
 }
 
-bool PluginInstance::HandleCompositionUpdate(
+bool PluginInstanceImpl::HandleCompositionUpdate(
     const base::string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   return SendCompositionEventWithUnderlineInformationToPlugin(
       PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE,
       text, underlines, selection_start, selection_end);
 }
 
-bool PluginInstance::HandleCompositionEnd(const base::string16& text) {
+bool PluginInstanceImpl::HandleCompositionEnd(const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_END,
                                       text);
 }
 
-bool PluginInstance::HandleTextInput(const base::string16& text) {
+bool PluginInstanceImpl::HandleTextInput(const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_TEXT,
                                       text);
 }
 
-void PluginInstance::GetSurroundingText(base::string16* text,
-                                        ui::Range* range) const {
+void PluginInstanceImpl::GetSurroundingText(base::string16* text,
+                                            ui::Range* range) const {
   std::vector<size_t> offsets;
   offsets.push_back(selection_anchor_);
   offsets.push_back(selection_caret_);
   *text = base::UTF8ToUTF16AndAdjustOffsets(surrounding_text_, &offsets);
   range->set_start(offsets[0] == base::string16::npos ? text->size()
                                                       : offsets[0]);
   range->set_end(offsets[1] == base::string16::npos ? text->size()
                                                     : offsets[1]);
 }
 
-bool PluginInstance::IsPluginAcceptingCompositionEvents() const {
+bool PluginInstanceImpl::IsPluginAcceptingCompositionEvents() const {
   return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_IME) ||
       (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
 }
 
-gfx::Rect PluginInstance::GetCaretBounds() const {
+gfx::Rect PluginInstanceImpl::GetCaretBounds() const {
   if (!text_input_caret_set_) {
     // If it is never set by the plugin, use the bottom left corner.
     return gfx::Rect(view_data_.rect.point.x,
                      view_data_.rect.point.y + view_data_.rect.size.height,
                      0, 0);
   }
 
   // TODO(kinaba) Take CSS transformation into accont.
   // TODO(kinaba) Take bounding_box into account. On some platforms, an
   // "exclude rectangle" where candidate window must avoid the region can be
   // passed to IME. Currently, we pass only the caret rectangle because
   // it is the only information supported uniformly in Chromium.
   gfx::Rect caret(text_input_caret_);
   caret.Offset(view_data_.rect.point.x, view_data_.rect.point.y);
   return caret;
 }
 
-bool PluginInstance::HandleInputEvent(const WebKit::WebInputEvent& event,
-                                      WebCursorInfo* cursor_info) {
-  TRACE_EVENT0("ppapi", "PluginInstance::HandleInputEvent");
+bool PluginInstanceImpl::HandleInputEvent(const WebKit::WebInputEvent& event,
+                                          WebCursorInfo* cursor_info) {
+  TRACE_EVENT0("ppapi", "PluginInstanceImpl::HandleInputEvent");
 
   if (WebInputEvent::isMouseEventType(event.type))
     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<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
 
   bool rv = false;
   if (LoadInputEventInterface()) {
     PP_InputEvent_Class event_class = ClassifyInputEvent(event.type);
     if (!event_class)
       return false;
 
     if ((filtered_input_event_mask_ & event_class) ||
         (input_event_mask_ & event_class)) {
       // Actually send the event.
@@ skipping 25 matching lines @@
             pp_instance(), event_resource->pp_resource()));
       }
     }
   }
 
   if (cursor_)
     *cursor_info = *cursor_;
   return rv;
 }
 
-void PluginInstance::HandleMessage(PP_Var message) {
-  TRACE_EVENT0("ppapi", "PluginInstance::HandleMessage");
+void PluginInstanceImpl::HandleMessage(PP_Var message) {
+  TRACE_EVENT0("ppapi", "PluginInstanceImpl::HandleMessage");
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadMessagingInterface())
     return;
   plugin_messaging_interface_->HandleMessage(pp_instance(), message);
 }
 
-PP_Var PluginInstance::GetInstanceObject() {
+PP_Var PluginInstanceImpl::GetInstanceObject() {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
 
   // If the plugin supports the private instance interface, try to retrieve its
   // instance object.
   if (LoadPrivateInterface())
     return plugin_private_interface_->GetInstanceObject(pp_instance());
   return PP_MakeUndefined();
 }
 
-void PluginInstance::ViewChanged(const gfx::Rect& position,
-                                 const gfx::Rect& clip,
-                                 const std::vector<gfx::Rect>& cut_outs_rects) {
+void PluginInstanceImpl::ViewChanged(
+    const gfx::Rect& position,
+    const gfx::Rect& clip,
+    const std::vector<gfx::Rect>& cut_outs_rects) {
   // WebKit can give weird (x,y) positions for empty clip rects (since the
   // position technically doesn't matter). But we want to make these
   // consistent since this is given to the plugin, so force everything to 0
   // in the "everything is clipped" case.
   gfx::Rect new_clip;
   if (!clip.IsEmpty())
     new_clip = clip;
 
   cut_outs_rects_ = cut_outs_rects;
 
@@ skipping 29 matching lines @@
       ResetSizeAttributesAfterFullscreen();
       return;
     }
   }
 
   UpdateFlashFullscreenState(fullscreen_container_ != NULL);
 
   SendDidChangeView();
 }
 
-void PluginInstance::SetWebKitFocus(bool has_focus) {
+void PluginInstanceImpl::SetWebKitFocus(bool has_focus) {
   if (has_webkit_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_webkit_focus_ = has_focus;
   if (PluginHasFocus() != old_plugin_focus)
     SendFocusChangeNotification();
 }
 
-void PluginInstance::SetContentAreaFocus(bool has_focus) {
+void PluginInstanceImpl::SetContentAreaFocus(bool has_focus) {
   if (has_content_area_focus_ == has_focus)
     return;
 
   bool old_plugin_focus = PluginHasFocus();
   has_content_area_focus_ = has_focus;
   if (PluginHasFocus() != old_plugin_focus)
     SendFocusChangeNotification();
 }
 
-void PluginInstance::PageVisibilityChanged(bool is_visible) {
+void PluginInstanceImpl::PageVisibilityChanged(bool is_visible) {
   if (is_visible == view_data_.is_page_visible)
     return;  // Nothing to do.
   view_data_.is_page_visible = is_visible;
 
   // If the initial DidChangeView notification hasn't been sent to the plugin,
   // let it pass the visibility state for us, instead of sending a notification
-  // immediately. It is possible that PluginInstance::ViewChanged() hasn't been
-  // called for the first time. In that case, most of the fields in |view_data_|
-  // haven't been properly initialized.
+  // immediately. It is possible that PluginInstanceImpl::ViewChanged() hasn't
+  // been called for the first time. In that case, most of the fields in
+  // |view_data_| haven't been properly initialized.
   if (sent_initial_did_change_view_)
     SendDidChangeView();
 }
 
-void PluginInstance::ViewWillInitiatePaint() {
+void PluginInstanceImpl::ViewWillInitiatePaint() {
   if (GetBoundGraphics2D())
     GetBoundGraphics2D()->ViewWillInitiatePaint();
   else if (bound_graphics_3d_.get())
     bound_graphics_3d_->ViewWillInitiatePaint();
 }
 
-void PluginInstance::ViewInitiatedPaint() {
+void PluginInstanceImpl::ViewInitiatedPaint() {
   if (GetBoundGraphics2D())
     GetBoundGraphics2D()->ViewInitiatedPaint();
   else if (bound_graphics_3d_.get())
     bound_graphics_3d_->ViewInitiatedPaint();
 }
 
-void PluginInstance::ViewFlushedPaint() {
+void PluginInstanceImpl::ViewFlushedPaint() {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (GetBoundGraphics2D())
     GetBoundGraphics2D()->ViewFlushedPaint();
   else if (bound_graphics_3d_.get())
     bound_graphics_3d_->ViewFlushedPaint();
 }
 
-bool PluginInstance::GetBitmapForOptimizedPluginPaint(
+bool PluginInstanceImpl::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip,
     float* scale_factor) {
   if (!always_on_top_)
     return false;
   if (!GetBoundGraphics2D() || !GetBoundGraphics2D()->IsAlwaysOpaque())
     return false;
 
@@ skipping 36 matching lines @@
   plugin_backing_store_rect.Offset(plugin_offset);
   *location = plugin_backing_store_rect;
   clip_page.Offset(plugin_offset);
   *clip = clip_page;
   // The plugin scale factor is inverted, e.g. for a device scale factor of 2x
   // the plugin scale factor is 0.5.
   *scale_factor = 1.0 / scale;
   return true;
 }
 
-base::string16 PluginInstance::GetSelectedText(bool html) {
+base::string16 PluginInstanceImpl::GetSelectedText(bool html) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadSelectionInterface())
     return base::string16();
 
   PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(),
                                                            PP_FromBool(html));
   StringVar* string = StringVar::FromPPVar(rv);
   base::string16 selection;
   if (string)
     selection = UTF8ToUTF16(string->value());
   // Release the ref the plugin transfered to us.
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(rv);
   return selection;
 }
 
-base::string16 PluginInstance::GetLinkAtPosition(const gfx::Point& point) {
+base::string16 PluginInstanceImpl::GetLinkAtPosition(const gfx::Point& point) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadPdfInterface())
     return base::string16();
 
   PP_Point p;
   p.x = point.x();
   p.y = point.y();
   PP_Var rv = plugin_pdf_interface_->GetLinkAtPosition(pp_instance(), p);
   StringVar* string = StringVar::FromPPVar(rv);
   base::string16 link;
   if (string)
     link = UTF8ToUTF16(string->value());
   // Release the ref the plugin transfered to us.
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(rv);
   return link;
 }
 
-void PluginInstance::RequestSurroundingText(
+void PluginInstanceImpl::RequestSurroundingText(
     size_t desired_number_of_characters) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadTextInputInterface())
     return;
   plugin_textinput_interface_->RequestSurroundingText(
       pp_instance(), desired_number_of_characters);
 }
 
-void PluginInstance::Zoom(double factor, bool text_only) {
+void PluginInstanceImpl::Zoom(double factor, bool text_only) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadZoomInterface())
     return;
   plugin_zoom_interface_->Zoom(pp_instance(), factor, PP_FromBool(text_only));
 }
 
-bool PluginInstance::StartFind(const base::string16& search_text,
-                               bool case_sensitive,
-                               int identifier) {
+bool PluginInstanceImpl::StartFind(const base::string16& search_text,
+                                   bool case_sensitive,
+                                   int identifier) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadFindInterface())
     return false;
   find_identifier_ = identifier;
   return PP_ToBool(
       plugin_find_interface_->StartFind(
           pp_instance(),
           UTF16ToUTF8(search_text.c_str()).c_str(),
           PP_FromBool(case_sensitive)));
 }
 
-void PluginInstance::SelectFindResult(bool forward) {
+void PluginInstanceImpl::SelectFindResult(bool forward) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (LoadFindInterface())
     plugin_find_interface_->SelectFindResult(pp_instance(),
                                              PP_FromBool(forward));
 }
 
-void PluginInstance::StopFind() {
+void PluginInstanceImpl::StopFind() {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadFindInterface())
     return;
   find_identifier_ = -1;
   plugin_find_interface_->StopFind(pp_instance());
 }
 
-bool PluginInstance::LoadFindInterface() {
+bool PluginInstanceImpl::LoadFindInterface() {
   if (!plugin_find_interface_) {
     plugin_find_interface_ =
         static_cast<const PPP_Find_Dev*>(module_->GetPluginInterface(
             PPP_FIND_DEV_INTERFACE));
   }
 
   return !!plugin_find_interface_;
 }
 
-bool PluginInstance::LoadInputEventInterface() {
+bool PluginInstanceImpl::LoadInputEventInterface() {
   if (!checked_for_plugin_input_event_interface_) {
     checked_for_plugin_input_event_interface_ = true;
     plugin_input_event_interface_ =
         static_cast<const PPP_InputEvent*>(module_->GetPluginInterface(
             PPP_INPUT_EVENT_INTERFACE));
   }
   return !!plugin_input_event_interface_;
 }
 
-bool PluginInstance::LoadMessagingInterface() {
+bool PluginInstanceImpl::LoadMessagingInterface() {
   if (!checked_for_plugin_messaging_interface_) {
     checked_for_plugin_messaging_interface_ = true;
     plugin_messaging_interface_ =
         static_cast<const PPP_Messaging*>(module_->GetPluginInterface(
             PPP_MESSAGING_INTERFACE));
   }
   return !!plugin_messaging_interface_;
 }
 
-bool PluginInstance::LoadMouseLockInterface() {
+bool PluginInstanceImpl::LoadMouseLockInterface() {
   if (!plugin_mouse_lock_interface_) {
     plugin_mouse_lock_interface_ =
         static_cast<const PPP_MouseLock*>(module_->GetPluginInterface(
             PPP_MOUSELOCK_INTERFACE));
   }
 
   return !!plugin_mouse_lock_interface_;
 }
 
-bool PluginInstance::LoadPdfInterface() {
+bool PluginInstanceImpl::LoadPdfInterface() {
   if (!checked_for_plugin_pdf_interface_) {
     checked_for_plugin_pdf_interface_ = true;
     plugin_pdf_interface_ =
         static_cast<const PPP_Pdf_1*>(module_->GetPluginInterface(
             PPP_PDF_INTERFACE_1));
   }
 
   return !!plugin_pdf_interface_;
 }
 
-bool PluginInstance::LoadPrintInterface() {
+bool PluginInstanceImpl::LoadPrintInterface() {
   // Only check for the interface if the plugin has dev permission.
   if (!module_->permissions().HasPermission(::ppapi::PERMISSION_DEV))
     return false;
   if (!plugin_print_interface_) {
     plugin_print_interface_ = static_cast<const PPP_Printing_Dev*>(
         module_->GetPluginInterface(PPP_PRINTING_DEV_INTERFACE));
   }
   return !!plugin_print_interface_;
 }
 
-bool PluginInstance::LoadPrivateInterface() {
+bool PluginInstanceImpl::LoadPrivateInterface() {
   // Only check for the interface if the plugin has private permission.
   if (!module_->permissions().HasPermission(::ppapi::PERMISSION_PRIVATE))
     return false;
   if (!plugin_private_interface_) {
     plugin_private_interface_ = static_cast<const PPP_Instance_Private*>(
         module_->GetPluginInterface(PPP_INSTANCE_PRIVATE_INTERFACE));
   }
 
   return !!plugin_private_interface_;
 }
 
-bool PluginInstance::LoadSelectionInterface() {
+bool PluginInstanceImpl::LoadSelectionInterface() {
   if (!plugin_selection_interface_) {
     plugin_selection_interface_ =
         static_cast<const PPP_Selection_Dev*>(module_->GetPluginInterface(
             PPP_SELECTION_DEV_INTERFACE));
   }
   return !!plugin_selection_interface_;
 }
 
-bool PluginInstance::LoadTextInputInterface() {
+bool PluginInstanceImpl::LoadTextInputInterface() {
   if (!plugin_textinput_interface_) {
     plugin_textinput_interface_ =
         static_cast<const PPP_TextInput_Dev*>(module_->GetPluginInterface(
             PPP_TEXTINPUT_DEV_INTERFACE));
   }
 
   return !!plugin_textinput_interface_;
 }
 
-bool PluginInstance::LoadZoomInterface() {
+bool PluginInstanceImpl::LoadZoomInterface() {
   if (!plugin_zoom_interface_) {
     plugin_zoom_interface_ =
         static_cast<const PPP_Zoom_Dev*>(module_->GetPluginInterface(
             PPP_ZOOM_DEV_INTERFACE));
   }
 
   return !!plugin_zoom_interface_;
 }
 
-bool PluginInstance::PluginHasFocus() const {
+bool PluginInstanceImpl::PluginHasFocus() const {
   return flash_fullscreen_ || (has_webkit_focus_ && has_content_area_focus_);
 }
 
-void PluginInstance::SendFocusChangeNotification() {
-  // This call can happen during PluginInstance destruction, because WebKit
+void PluginInstanceImpl::SendFocusChangeNotification() {
+  // This call can happen during PluginInstanceImpl 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);
   instance_interface_->DidChangeFocus(pp_instance(), PP_FromBool(has_focus));
 }
 
-void PluginInstance::UpdateTouchEventRequest() {
+void PluginInstanceImpl::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);
 }
 
-bool PluginInstance::IsAcceptingWheelEvents() const {
+bool PluginInstanceImpl::IsAcceptingWheelEvents() const {
   return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL) ||
       (input_event_mask_ & PP_INPUTEVENT_CLASS_WHEEL);
 }
 
-void PluginInstance::ScheduleAsyncDidChangeView() {
+void PluginInstanceImpl::ScheduleAsyncDidChangeView() {
   if (view_change_weak_ptr_factory_.HasWeakPtrs())
     return;  // Already scheduled.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&PluginInstance::SendAsyncDidChangeView,
+      base::Bind(&PluginInstanceImpl::SendAsyncDidChangeView,
                  view_change_weak_ptr_factory_.GetWeakPtr()));
 }
 
-void PluginInstance::SendAsyncDidChangeView() {
+void PluginInstanceImpl::SendAsyncDidChangeView() {
   // The bound callback that owns the weak pointer is still valid until after
   // this function returns. SendDidChangeView checks HasWeakPtrs, so we need to
   // invalidate them here.
   // NOTE: If we ever want to have more than one pending callback, it should
   // use a different factory, or we should have a different strategy here.
   view_change_weak_ptr_factory_.InvalidateWeakPtrs();
   SendDidChangeView();
 }
 
-void PluginInstance::SendDidChangeView() {
+void PluginInstanceImpl::SendDidChangeView() {
   // Don't send DidChangeView to crashed plugins.
   if (module()->is_crashed())
     return;
 
   if (view_change_weak_ptr_factory_.HasWeakPtrs() ||
       (sent_initial_did_change_view_ &&
        last_sent_view_data_.Equals(view_data_)))
     return;  // Nothing to update.
 
   const PP_Size& size = view_data_.rect.size;
@@ skipping 11 matching lines @@
   ScopedPPResource resource(
       ScopedPPResource::PassRef(),
       (new PPB_View_Shared(::ppapi::OBJECT_IS_IMPL,
                            pp_instance(), view_data_))->GetReference());
 
   instance_interface_->DidChangeView(pp_instance(), resource,
                                      &view_data_.rect,
                                      &view_data_.clip_rect);
 }
 
-void PluginInstance::ReportGeometry() {
+void PluginInstanceImpl::ReportGeometry() {
   // If this call was delayed, we may have transitioned back to fullscreen in
   // the mean time, so only report the geometry if we are actually in normal
   // mode.
   if (container_ && !fullscreen_container_ && !flash_fullscreen_)
     container_->reportGeometry();
 }
 
-bool PluginInstance::GetPreferredPrintOutputFormat(
+bool PluginInstanceImpl::GetPreferredPrintOutputFormat(
     PP_PrintOutputFormat_Dev* format) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!LoadPrintInterface())
     return false;
   uint32_t supported_formats =
       plugin_print_interface_->QuerySupportedFormats(pp_instance());
   if (supported_formats & PP_PRINTOUTPUTFORMAT_PDF) {
     *format = PP_PRINTOUTPUTFORMAT_PDF;
     return true;
   }
   return false;
 }
 
-bool PluginInstance::SupportsPrintInterface() {
+bool PluginInstanceImpl::SupportsPrintInterface() {
   PP_PrintOutputFormat_Dev format;
   return GetPreferredPrintOutputFormat(&format);
 }
 
-bool PluginInstance::IsPrintScalingDisabled() {
+bool PluginInstanceImpl::IsPrintScalingDisabled() {
   DCHECK(plugin_print_interface_);
   if (!plugin_print_interface_)
     return false;
   return plugin_print_interface_->IsScalingDisabled(pp_instance()) == PP_TRUE;
 }
 
-int PluginInstance::PrintBegin(const WebPrintParams& print_params) {
+int PluginInstanceImpl::PrintBegin(const WebPrintParams& print_params) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   PP_PrintOutputFormat_Dev format;
   if (!GetPreferredPrintOutputFormat(&format)) {
     // PrintBegin should not have been called since SupportsPrintInterface
     // would have returned false;
     NOTREACHED();
     return 0;
   }
   int num_pages = 0;
   PP_PrintSettings_Dev print_settings;
   print_settings.printable_area = PP_FromGfxRect(print_params.printableArea);
   print_settings.content_area = PP_FromGfxRect(print_params.printContentArea);
   print_settings.paper_size = PP_FromGfxSize(print_params.paperSize);
   print_settings.dpi = print_params.printerDPI;
   print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
   print_settings.grayscale = PP_FALSE;
   print_settings.print_scaling_option = static_cast<PP_PrintScalingOption_Dev>(
       print_params.printScalingOption);
   print_settings.format = format;
   num_pages = plugin_print_interface_->Begin(pp_instance(),
                                              &print_settings);
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
   canvas_.clear();
   ranges_.clear();
   return num_pages;
 }
 
-bool PluginInstance::PrintPage(int page_number, WebKit::WebCanvas* canvas) {
+bool PluginInstanceImpl::PrintPage(int page_number, WebKit::WebCanvas* canvas) {
 #if defined(ENABLE_PRINTING)
   DCHECK(plugin_print_interface_);
   PP_PrintPageNumberRange_Dev page_range;
   page_range.first_page_number = page_range.last_page_number = page_number;
   // The canvas only has a metafile on it for print preview.
   bool save_for_later =
       (printing::MetafileSkiaWrapper::GetMetafileFromCanvas(*canvas) != NULL);
 #if defined(OS_MACOSX) || defined(OS_WIN)
   save_for_later = save_for_later && skia::IsPreviewMetafile(*canvas);
 #endif
   if (save_for_later) {
     ranges_.push_back(page_range);
     canvas_ = skia::SharePtr(canvas);
     return true;
   } else {
     return PrintPageHelper(&page_range, 1, canvas);
   }
 #else  // defined(ENABLED_PRINTING)
   return false;
 #endif
 }
 
-bool PluginInstance::PrintPageHelper(PP_PrintPageNumberRange_Dev* page_ranges,
-                                     int num_ranges,
-                                     WebKit::WebCanvas* canvas) {
+bool PluginInstanceImpl::PrintPageHelper(
+    PP_PrintPageNumberRange_Dev* page_ranges,
+    int num_ranges,
+    WebKit::WebCanvas* canvas) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   DCHECK(plugin_print_interface_);
   if (!plugin_print_interface_)
     return false;
   PP_Resource print_output = plugin_print_interface_->PrintPages(
       pp_instance(), page_ranges, num_ranges);
   if (!print_output)
     return false;
 
   bool ret = false;
 
   if (current_print_settings_.format == PP_PRINTOUTPUTFORMAT_PDF)
     ret = PrintPDFOutput(print_output, canvas);
 
   // Now we need to release the print output resource.
   PluginModule::GetCore()->ReleaseResource(print_output);
 
   return ret;
 }
 
-void PluginInstance::PrintEnd() {
+void PluginInstanceImpl::PrintEnd() {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   if (!ranges_.empty())
     PrintPageHelper(&(ranges_.front()), ranges_.size(), canvas_.get());
   canvas_.clear();
   ranges_.clear();
 
   DCHECK(plugin_print_interface_);
   if (plugin_print_interface_)
     plugin_print_interface_->End(pp_instance());
 
   memset(&current_print_settings_, 0, sizeof(current_print_settings_));
 #if defined(OS_MACOSX)
   last_printed_page_ = NULL;
 #endif  // defined(OS_MACOSX)
 }
 
-bool PluginInstance::CanRotateView() {
+bool PluginInstanceImpl::CanRotateView() {
   if (!LoadPdfInterface())
     return false;
 
   return true;
 }
 
-void PluginInstance::SetBoundGraphics2DForTest(
+void PluginInstanceImpl::SetBoundGraphics2DForTest(
     PluginDelegate::PlatformGraphics2D* graphics) {
   BindGraphics(pp_instance(), 0);  // Unbind any old stuff.
   if (graphics) {
     bound_graphics_2d_platform_ = graphics;
     bound_graphics_2d_platform_->BindToInstance(this);
   }
 }
 
-void PluginInstance::RotateView(WebPlugin::RotationType type) {
+void PluginInstanceImpl::RotateView(WebPlugin::RotationType type) {
   if (!LoadPdfInterface())
     return;
   PP_PrivatePageTransformType transform_type =
       type == WebPlugin::RotationType90Clockwise ?
       PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CW :
       PP_PRIVATEPAGETRANSFORMTYPE_ROTATE_90_CCW;
   plugin_pdf_interface_->Transform(pp_instance(), transform_type);
   // NOTE: plugin instance may have been deleted.
 }
 
-bool PluginInstance::FlashIsFullscreenOrPending() {
+bool PluginInstanceImpl::FlashIsFullscreenOrPending() {
   return fullscreen_container_ != NULL;
 }
 
-bool PluginInstance::IsFullscreenOrPending() {
+bool PluginInstanceImpl::IsFullscreenOrPending() {
   return desired_fullscreen_state_;
 }
 
-bool PluginInstance::SetFullscreen(bool fullscreen) {
+bool PluginInstanceImpl::SetFullscreen(bool fullscreen) {
   // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
 
   // Check whether we are trying to switch to the state we're already going
   // to (i.e. if we're already switching to fullscreen but the fullscreen
   // container isn't ready yet, don't do anything more).
   if (fullscreen == IsFullscreenOrPending())
     return false;
 
   // Check whether we are trying to switch while the state is in transition.
   // The 2nd request gets dropped while messing up the internal state, so
   // disallow this.
@@ skipping 13 matching lines @@
     // so we will tweak plugin's attributes to support the expected behavior.
     KeepSizeAttributesBeforeFullscreen();
     SetSizeAttributesForFullscreen();
     container_->element().requestFullScreen();
   } else {
     container_->element().document().cancelFullScreen();
   }
   return true;
 }
 
-void PluginInstance::FlashSetFullscreen(bool fullscreen, bool delay_report) {
-  TRACE_EVENT0("ppapi", "PluginInstance::FlashSetFullscreen");
-  // Keep a reference on the stack. See NOTE above.
-  scoped_refptr<PluginInstance> ref(this);
-
-  // We check whether we are trying to switch to the state we're already going
-  // to (i.e. if we're already switching to fullscreen but the fullscreen
-  // container isn't ready yet, don't do anything more).
-  if (fullscreen == FlashIsFullscreenOrPending())
-    return;
-
-  // Unbind current 2D or 3D graphics context.
-  VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
-  if (fullscreen) {
-    DCHECK(!fullscreen_container_);
-    fullscreen_container_ = delegate_->CreateFullscreenContainer(this);
-    UpdateLayer();
-  } else {
-    DCHECK(fullscreen_container_);
-    fullscreen_container_->Destroy();
-    fullscreen_container_ = NULL;
-    UpdateFlashFullscreenState(false);
-    if (!delay_report) {
-      ReportGeometry();
-    } else {
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE, base::Bind(&PluginInstance::ReportGeometry, this));
-    }
-  }
-}
-
-void PluginInstance::UpdateFlashFullscreenState(bool flash_fullscreen) {
+void PluginInstanceImpl::UpdateFlashFullscreenState(bool flash_fullscreen) {
   bool is_mouselock_pending = TrackedCallback::IsPending(lock_mouse_callback_);
 
   if (flash_fullscreen == flash_fullscreen_) {
     // Manually clear callback when fullscreen fails with mouselock pending.
     if (!flash_fullscreen && is_mouselock_pending)
       lock_mouse_callback_->Run(PP_ERROR_FAILED);
     return;
   }
 
   PPB_Graphics3D_Impl* graphics_3d  = bound_graphics_3d_.get();
@@ skipping 13 matching lines @@
       WebScopedUserGesture user_gesture(CurrentUserGestureToken());
       if (!delegate()->LockMouse(this))
         lock_mouse_callback_->Run(PP_ERROR_FAILED);
     }
   }
 
   if (PluginHasFocus() != old_plugin_focus)
     SendFocusChangeNotification();
 }
 
-int32_t PluginInstance::Navigate(const ::ppapi::URLRequestInfoData& request,
-                                 const char* target,
-                                 bool from_user_action) {
-  if (!container_)
-    return PP_ERROR_FAILED;
-
-  WebDocument document = container_->element().document();
-  WebFrame* frame = document.frame();
-  if (!frame)
-    return PP_ERROR_FAILED;
-
-  ::ppapi::URLRequestInfoData completed_request = request;
-
-  WebURLRequest web_request;
-  if (!CreateWebURLRequest(&completed_request, frame, &web_request))
-    return PP_ERROR_FAILED;
-  web_request.setFirstPartyForCookies(document.firstPartyForCookies());
-  web_request.setHasUserGesture(from_user_action);
-
-  GURL gurl(web_request.url());
-  if (gurl.SchemeIs("javascript")) {
-    // In imitation of the NPAPI implementation, only |target_frame == frame| is
-    // allowed for security reasons.
-    WebFrame* target_frame =
-        frame->view()->findFrameByName(WebString::fromUTF8(target), frame);
-    if (target_frame != frame)
-      return PP_ERROR_NOACCESS;
-
-    // TODO(viettrungluu): NPAPI sends the result back to the plugin -- do we
-    // need that?
-    WebString result = container_->executeScriptURL(gurl, from_user_action);
-    return result.isNull() ? PP_ERROR_FAILED : PP_OK;
-  }
-
-  // Only GETs and POSTs are supported.
-  if (web_request.httpMethod() != "GET" &&
-      web_request.httpMethod() != "POST")
-    return PP_ERROR_BADARGUMENT;
-
-  WebString target_str = WebString::fromUTF8(target);
-  container_->loadFrameRequest(web_request, target_str, false, NULL);
-  return PP_OK;
-}
-
-bool PluginInstance::IsRectTopmost(const gfx::Rect& rect) {
-  if (flash_fullscreen_)
-    return true;
-
-  return container_->isRectTopmost(rect);
-}
-
-bool PluginInstance::IsViewAccelerated() {
+bool PluginInstanceImpl::IsViewAccelerated() {
   if (!container_)
     return false;
 
   WebDocument document = container_->element().document();
   WebFrame* frame = document.frame();
   if (!frame)
     return false;
   WebView* view = frame->view();
   if (!view)
     return false;
 
   return view->isAcceleratedCompositingActive();
 }
 
-PluginDelegate::PlatformContext3D* PluginInstance::CreateContext3D() {
+PluginDelegate::PlatformContext3D* PluginInstanceImpl::CreateContext3D() {
   return delegate_->CreateContext3D();
 }
 
-bool PluginInstance::PrintPDFOutput(PP_Resource print_output,
-                                    WebKit::WebCanvas* canvas) {
+bool PluginInstanceImpl::PrintPDFOutput(PP_Resource print_output,
+                                        WebKit::WebCanvas* canvas) {
 #if defined(ENABLE_PRINTING)
   ::ppapi::thunk::EnterResourceNoLock<PPB_Buffer_API> enter(print_output, true);
   if (enter.failed())
     return false;
 
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size()) {
     NOTREACHED();
     return false;
   }
@@ skipping 70 matching lines @@
     skia::EndPlatformPaint(canvas);
   }
 #endif  // defined(OS_WIN)
 
   return ret;
 #else  // defined(ENABLE_PRINTING)
   return false;
 #endif
 }
 
-PluginDelegate::PlatformGraphics2D* PluginInstance::GetBoundGraphics2D() const {
+PluginDelegate::PlatformGraphics2D*
+    PluginInstanceImpl::GetBoundGraphics2D() const {
   return bound_graphics_2d_platform_;
 }
 
 static void IgnoreCallback(unsigned, bool) {}
 
-void PluginInstance::UpdateLayer() {
+void PluginInstanceImpl::UpdateLayer() {
   if (!container_)
     return;
 
   gpu::Mailbox mailbox;
   if (bound_graphics_3d_.get()) {
     PluginDelegate::PlatformContext3D* context =
         bound_graphics_3d_->platform_context();
     context->GetBackingMailbox(&mailbox);
   }
   bool want_layer = !mailbox.IsZero();
@@ skipping 23 matching lines @@
     } else {
       container_->setWebLayer(web_layer_.get());
       texture_layer_->SetContentsOpaque(bound_graphics_3d_->IsOpaque());
     }
     texture_layer_->SetTextureMailbox(
         cc::TextureMailbox(mailbox, base::Bind(&IgnoreCallback), 0));
   }
   layer_bound_to_fullscreen_ = !!fullscreen_container_;
 }
 
-void PluginInstance::AddPluginObject(PluginObject* plugin_object) {
+void PluginInstanceImpl::AddPluginObject(PluginObject* plugin_object) {
   DCHECK(live_plugin_objects_.find(plugin_object) ==
          live_plugin_objects_.end());
   live_plugin_objects_.insert(plugin_object);
 }
 
-void PluginInstance::RemovePluginObject(PluginObject* plugin_object) {
+void PluginInstanceImpl::RemovePluginObject(PluginObject* plugin_object) {
   // Don't actually verify that the object is in the set since during module
   // deletion we'll be in the process of freeing them.
   live_plugin_objects_.erase(plugin_object);
 }
 
-bool PluginInstance::IsFullPagePlugin() const {
-  WebFrame* frame = container()->element().document().frame();
-  return frame->view()->mainFrame()->document().isPluginDocument();
-}
-
-bool PluginInstance::IsProcessingUserGesture() {
+bool PluginInstanceImpl::IsProcessingUserGesture() {
   PP_TimeTicks now =
       ::ppapi::TimeTicksToPPTimeTicks(base::TimeTicks::Now());
   // Give a lot of slack so tests won't be flaky.
   const PP_TimeTicks kUserGestureDurationInSeconds = 10.0;
   return pending_user_gesture_token_.hasGestures() &&
          (now - pending_user_gesture_ < kUserGestureDurationInSeconds);
 }
 
-WebUserGestureToken PluginInstance::CurrentUserGestureToken() {
+WebUserGestureToken PluginInstanceImpl::CurrentUserGestureToken() {
   if (!IsProcessingUserGesture())
     pending_user_gesture_token_ = WebUserGestureToken();
   return pending_user_gesture_token_;
 }
 
-void PluginInstance::OnLockMouseACK(bool succeeded) {
+void PluginInstanceImpl::OnLockMouseACK(bool succeeded) {
   if (TrackedCallback::IsPending(lock_mouse_callback_))
     lock_mouse_callback_->Run(succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
-void PluginInstance::OnMouseLockLost() {
+void PluginInstanceImpl::OnMouseLockLost() {
   if (LoadMouseLockInterface())
     plugin_mouse_lock_interface_->MouseLockLost(pp_instance());
 }
 
-void PluginInstance::HandleMouseLockedInputEvent(
+void PluginInstanceImpl::HandleMouseLockedInputEvent(
     const WebKit::WebMouseEvent& event) {
   // |cursor_info| is ignored since it is hidden when the mouse is locked.
   WebKit::WebCursorInfo cursor_info;
   HandleInputEvent(event, &cursor_info);
 }
 
-void PluginInstance::SimulateInputEvent(const InputEventData& input_event) {
+void PluginInstanceImpl::SimulateInputEvent(const InputEventData& input_event) {
   WebView* web_view = container()->element().document().frame()->view();
   if (!web_view) {
     NOTREACHED();
     return;
   }
 
   bool handled = SimulateIMEEvent(input_event);
   if (handled)
     return;
 
   std::vector<linked_ptr<WebInputEvent> > events =
       CreateSimulatedWebInputEvents(
           input_event,
           view_data_.rect.point.x + view_data_.rect.size.width / 2,
           view_data_.rect.point.y + view_data_.rect.size.height / 2);
   for (std::vector<linked_ptr<WebInputEvent> >::iterator it = events.begin();
       it != events.end(); ++it) {
     web_view->handleInputEvent(*it->get());
   }
 }
 
-bool PluginInstance::SimulateIMEEvent(const InputEventData& input_event) {
+bool PluginInstanceImpl::SimulateIMEEvent(const InputEventData& input_event) {
   switch (input_event.event_type) {
     case PP_INPUTEVENT_TYPE_IME_COMPOSITION_START:
     case PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE:
       SimulateImeSetCompositionEvent(input_event);
       break;
     case PP_INPUTEVENT_TYPE_IME_COMPOSITION_END:
       DCHECK(input_event.character_text.empty());
       SimulateImeSetCompositionEvent(input_event);
       break;
     case PP_INPUTEVENT_TYPE_IME_TEXT:
       delegate()->SimulateImeConfirmComposition(
           UTF8ToUTF16(input_event.character_text));
       break;
     default:
       return false;
   }
   return true;
 }
 
-void PluginInstance::SimulateImeSetCompositionEvent(
+void PluginInstanceImpl::SimulateImeSetCompositionEvent(
     const InputEventData& input_event) {
   std::vector<size_t> offsets;
   offsets.push_back(input_event.composition_selection_start);
   offsets.push_back(input_event.composition_selection_end);
   offsets.insert(offsets.end(),
                  input_event.composition_segment_offsets.begin(),
                  input_event.composition_segment_offsets.end());
 
   base::string16 utf16_text =
       base::UTF8ToUTF16AndAdjustOffsets(input_event.character_text, &offsets);
 
   std::vector<WebKit::WebCompositionUnderline> underlines;
   for (size_t i = 2; i + 1 < offsets.size(); ++i) {
     WebKit::WebCompositionUnderline underline;
     underline.startOffset = offsets[i];
     underline.endOffset = offsets[i + 1];
     if (input_event.composition_target_segment == static_cast<int32_t>(i - 2))
       underline.thick = true;
     underlines.push_back(underline);
   }
 
   delegate()->SimulateImeSetComposition(
       utf16_text, underlines, offsets[0], offsets[1]);
 }
 
-ContentDecryptorDelegate* PluginInstance::GetContentDecryptorDelegate() {
+ContentDecryptorDelegate* PluginInstanceImpl::GetContentDecryptorDelegate() {
   if (content_decryptor_delegate_)
     return content_decryptor_delegate_.get();
 
   const PPP_ContentDecryptor_Private* plugin_decryption_interface =
       static_cast<const PPP_ContentDecryptor_Private*>(
           module_->GetPluginInterface(
               PPP_CONTENTDECRYPTOR_PRIVATE_INTERFACE));
   if (!plugin_decryption_interface)
     return NULL;
 
   content_decryptor_delegate_.reset(
       new ContentDecryptorDelegate(pp_instance_, plugin_decryption_interface));
   return content_decryptor_delegate_.get();
 }
 
-PP_Bool PluginInstance::BindGraphics(PP_Instance instance,
-                                     PP_Resource device) {
-  TRACE_EVENT0("ppapi", "PluginInstance::BindGraphics");
+PP_Bool PluginInstanceImpl::BindGraphics(PP_Instance instance,
+                                         PP_Resource device) {
+  TRACE_EVENT0("ppapi", "PluginInstanceImpl::BindGraphics");
   // The Graphics3D instance can't be destroyed until we call
   // UpdateLayer().
   scoped_refptr< ::ppapi::Resource> old_graphics = bound_graphics_3d_.get();
   if (bound_graphics_3d_.get()) {
     bound_graphics_3d_->BindToInstance(false);
     bound_graphics_3d_ = NULL;
   }
   if (bound_graphics_2d_platform_) {
     GetBoundGraphics2D()->BindToInstance(NULL);
     bound_graphics_2d_platform_ = NULL;
@@ skipping 32 matching lines @@
       bound_graphics_3d_ = graphics_3d;
       UpdateLayer();
       return PP_TRUE;
     }
   }
 
   // The instance cannot be bound or the device is not a valid resource type.
   return PP_FALSE;
 }
 
-PP_Bool PluginInstance::IsFullFrame(PP_Instance instance) {
+PP_Bool PluginInstanceImpl::IsFullFrame(PP_Instance instance) {
   return PP_FromBool(full_frame());
 }
 
-const ViewData* PluginInstance::GetViewData(PP_Instance instance) {
+const ViewData* PluginInstanceImpl::GetViewData(PP_Instance instance) {
   return &view_data_;
 }
 
-PP_Bool PluginInstance::FlashIsFullscreen(PP_Instance instance) {
+PP_Bool PluginInstanceImpl::FlashIsFullscreen(PP_Instance instance) {
   return PP_FromBool(flash_fullscreen_);
 }
 
-PP_Var PluginInstance::GetWindowObject(PP_Instance instance) {
+PP_Var PluginInstanceImpl::GetWindowObject(PP_Instance instance) {
   if (!container_)
     return PP_MakeUndefined();
 
   WebFrame* frame = container_->element().document().frame();
   if (!frame)
     return PP_MakeUndefined();
 
   return NPObjectToPPVar(this, frame->windowObject());
 }
 
-PP_Var PluginInstance::GetOwnerElementObject(PP_Instance instance) {
+PP_Var PluginInstanceImpl::GetOwnerElementObject(PP_Instance instance) {
   if (!container_)
     return PP_MakeUndefined();
   return NPObjectToPPVar(this, container_->scriptableObjectForElement());
 }
 
-PP_Var PluginInstance::ExecuteScript(PP_Instance instance,
-                                     PP_Var script,
-                                     PP_Var* exception) {
+PP_Var PluginInstanceImpl::ExecuteScript(PP_Instance instance,
+                                         PP_Var script,
+                                         PP_Var* exception) {
   // Executing the script may remove the plugin from the DOM, so we need to keep
   // a reference to ourselves so that we can still process the result after the
   // WebBindings::evaluate() below.
-  scoped_refptr<PluginInstance> ref(this);
+  scoped_refptr<PluginInstanceImpl> ref(this);
   TryCatch try_catch(exception);
   if (try_catch.has_exception())
     return PP_MakeUndefined();
 
   // Convert the script into an inconvenient NPString object.
   StringVar* script_string = StringVar::FromPPVar(script);
   if (!script_string) {
     try_catch.SetException("Script param to ExecuteScript must be a string.");
     return PP_MakeUndefined();
   }
@@ skipping 24 matching lines @@
     try_catch.SetException("Exception caught");
     WebBindings::releaseVariantValue(&result);
     return PP_MakeUndefined();
   }
 
   PP_Var ret = NPVariantToPPVar(this, &result);
   WebBindings::releaseVariantValue(&result);
   return ret;
 }
 
-uint32_t PluginInstance::GetAudioHardwareOutputSampleRate(
+uint32_t PluginInstanceImpl::GetAudioHardwareOutputSampleRate(
     PP_Instance instance) {
   return delegate()->GetAudioHardwareOutputSampleRate();
 }
 
-uint32_t PluginInstance::GetAudioHardwareOutputBufferSize(
+uint32_t PluginInstanceImpl::GetAudioHardwareOutputBufferSize(
     PP_Instance instance) {
   return delegate()->GetAudioHardwareOutputBufferSize();
 }
 
-PP_Var PluginInstance::GetDefaultCharSet(PP_Instance instance) {
+PP_Var PluginInstanceImpl::GetDefaultCharSet(PP_Instance instance) {
   std::string encoding = delegate()->GetDefaultEncoding();
   return StringVar::StringToPPVar(encoding);
 }
 
 // These PPB_ContentDecryptor_Private calls are responses to
 // PPP_ContentDecryptor_Private calls made on |content_decryptor_delegate_|.
 // Therefore, |content_decryptor_delegate_| must have been initialized when
 // the following methods are called.
-void PluginInstance::NeedKey(PP_Instance instance,
-                             PP_Var key_system_var,
-                             PP_Var session_id_var,
-                             PP_Var init_data_var) {
+void PluginInstanceImpl::NeedKey(PP_Instance instance,
+                                 PP_Var key_system_var,
+                                 PP_Var session_id_var,
+                                 PP_Var init_data_var) {
   content_decryptor_delegate_->NeedKey(
       key_system_var, session_id_var, init_data_var);
 }
 
-void PluginInstance::KeyAdded(PP_Instance instance,
-                              PP_Var key_system_var,
-                              PP_Var session_id_var) {
+void PluginInstanceImpl::KeyAdded(PP_Instance instance,
+                                  PP_Var key_system_var,
+                                  PP_Var session_id_var) {
   content_decryptor_delegate_->KeyAdded(key_system_var, session_id_var);
 }
 
-void PluginInstance::KeyMessage(PP_Instance instance,
-                                PP_Var key_system_var,
-                                PP_Var session_id_var,
-                                PP_Var message_var,
-                                PP_Var default_url_var) {
+void PluginInstanceImpl::KeyMessage(PP_Instance instance,
+                                    PP_Var key_system_var,
+                                    PP_Var session_id_var,
+                                    PP_Var message_var,
+                                    PP_Var default_url_var) {
   content_decryptor_delegate_->KeyMessage(
       key_system_var, session_id_var, message_var, default_url_var);
 }
 
-void PluginInstance::KeyError(PP_Instance instance,
-                              PP_Var key_system_var,
-                              PP_Var session_id_var,
-                              int32_t media_error,
-                              int32_t system_code) {
+void PluginInstanceImpl::KeyError(PP_Instance instance,
+                                  PP_Var key_system_var,
+                                  PP_Var session_id_var,
+                                  int32_t media_error,
+                                  int32_t system_code) {
   content_decryptor_delegate_->KeyError(
       key_system_var, session_id_var, media_error, system_code);
 }
 
-void PluginInstance::DeliverBlock(PP_Instance instance,
-                                  PP_Resource decrypted_block,
-                                  const PP_DecryptedBlockInfo* block_info) {
+void PluginInstanceImpl::DeliverBlock(PP_Instance instance,
+                                      PP_Resource decrypted_block,
+                                      const PP_DecryptedBlockInfo* block_info) {
   content_decryptor_delegate_->DeliverBlock(decrypted_block, block_info);
 }
 
-void PluginInstance::DecoderInitializeDone(PP_Instance instance,
-                                           PP_DecryptorStreamType decoder_type,
-                                           uint32_t request_id,
-                                           PP_Bool success) {
+void PluginInstanceImpl::DecoderInitializeDone(
+    PP_Instance instance,
+    PP_DecryptorStreamType decoder_type,
+    uint32_t request_id,
+    PP_Bool success) {
   content_decryptor_delegate_->DecoderInitializeDone(
       decoder_type, request_id, success);
 }
 
-void PluginInstance::DecoderDeinitializeDone(
+void PluginInstanceImpl::DecoderDeinitializeDone(
     PP_Instance instance,
     PP_DecryptorStreamType decoder_type,
     uint32_t request_id) {
   content_decryptor_delegate_->DecoderDeinitializeDone(decoder_type,
                                                        request_id);
 }
 
-void PluginInstance::DecoderResetDone(PP_Instance instance,
-                                      PP_DecryptorStreamType decoder_type,
-                                      uint32_t request_id) {
+void PluginInstanceImpl::DecoderResetDone(PP_Instance instance,
+                                          PP_DecryptorStreamType decoder_type,
+                                          uint32_t request_id) {
   content_decryptor_delegate_->DecoderResetDone(decoder_type, request_id);
 }
 
 
-void PluginInstance::DeliverFrame(PP_Instance instance,
-                                  PP_Resource decrypted_frame,
-                                  const PP_DecryptedFrameInfo* frame_info) {
+void PluginInstanceImpl::DeliverFrame(PP_Instance instance,
+                                      PP_Resource decrypted_frame,
+                                      const PP_DecryptedFrameInfo* frame_info) {
   content_decryptor_delegate_->DeliverFrame(decrypted_frame, frame_info);
 }
 
-void PluginInstance::DeliverSamples(PP_Instance instance,
-                                    PP_Resource audio_frames,
-                                    const PP_DecryptedBlockInfo* block_info) {
+void PluginInstanceImpl::DeliverSamples(
+    PP_Instance instance,
+    PP_Resource audio_frames,
+    const PP_DecryptedBlockInfo* block_info) {
   content_decryptor_delegate_->DeliverSamples(audio_frames, block_info);
 }
 
-void PluginInstance::NumberOfFindResultsChanged(PP_Instance instance,
-                                                int32_t total,
-                                                PP_Bool final_result) {
+void PluginInstanceImpl::NumberOfFindResultsChanged(PP_Instance instance,
+                                                    int32_t total,
+                                                    PP_Bool final_result) {
   DCHECK_NE(find_identifier_, -1);
   delegate_->NumberOfFindResultsChanged(find_identifier_, total,
                                         PP_ToBool(final_result));
 }
 
-void PluginInstance::SelectedFindResultChanged(PP_Instance instance,
-                                               int32_t index) {
+void PluginInstanceImpl::SelectedFindResultChanged(PP_Instance instance,
+                                                   int32_t index) {
   DCHECK_NE(find_identifier_, -1);
   delegate_->SelectedFindResultChanged(find_identifier_, index);
 }
 
-PP_Bool PluginInstance::IsFullscreen(PP_Instance instance) {
+PP_Bool PluginInstanceImpl::IsFullscreen(PP_Instance instance) {
   return PP_FromBool(view_data_.is_fullscreen);
 }
 
-PP_Bool PluginInstance::SetFullscreen(PP_Instance instance,
-                                      PP_Bool fullscreen) {
+PP_Bool PluginInstanceImpl::SetFullscreen(PP_Instance instance,
+                                          PP_Bool fullscreen) {
   return PP_FromBool(SetFullscreen(PP_ToBool(fullscreen)));
 }
 
-PP_Bool PluginInstance::GetScreenSize(PP_Instance instance, PP_Size* size) {
+PP_Bool PluginInstanceImpl::GetScreenSize(PP_Instance instance, PP_Size* size) {
   gfx::Size screen_size = delegate()->GetScreenSize();
   *size = PP_MakeSize(screen_size.width(), screen_size.height());
   return PP_TRUE;
 }
 
-::ppapi::Resource* PluginInstance::GetSingletonResource(
+::ppapi::Resource* PluginInstanceImpl::GetSingletonResource(
     PP_Instance instance,
     ::ppapi::SingletonResourceID id) {
   // Flash APIs and some others aren't implemented in-process.
   switch (id) {
     case ::ppapi::BROKER_SINGLETON_ID:
     case ::ppapi::BROWSER_FONT_SINGLETON_ID:
     case ::ppapi::CRX_FILESYSTEM_SINGLETON_ID:
     case ::ppapi::EXTENSIONS_COMMON_SINGLETON_ID:
     case ::ppapi::FLASH_CLIPBOARD_SINGLETON_ID:
     case ::ppapi::FLASH_FILE_SINGLETON_ID:
     case ::ppapi::FLASH_FULLSCREEN_SINGLETON_ID:
     case ::ppapi::FLASH_SINGLETON_ID:
     case ::ppapi::NETWORK_PROXY_SINGLETON_ID:
     case ::ppapi::PDF_SINGLETON_ID:
     case ::ppapi::TRUETYPE_FONT_SINGLETON_ID:
       NOTIMPLEMENTED();
       return NULL;
     case ::ppapi::GAMEPAD_SINGLETON_ID:
       return gamepad_impl_.get();
   }
 
   NOTREACHED();
   return NULL;
 }
 
-int32_t PluginInstance::RequestInputEvents(PP_Instance instance,
-                                           uint32_t event_classes) {
+int32_t PluginInstanceImpl::RequestInputEvents(PP_Instance instance,
+                                               uint32_t event_classes) {
   input_event_mask_ |= event_classes;
   filtered_input_event_mask_ &= ~(event_classes);
   RequestInputEventsHelper(event_classes);
   return ValidateRequestInputEvents(false, event_classes);
 }
 
-int32_t PluginInstance::RequestFilteringInputEvents(PP_Instance instance,
-                                                    uint32_t event_classes) {
+int32_t PluginInstanceImpl::RequestFilteringInputEvents(
+    PP_Instance instance,
+    uint32_t event_classes) {
   filtered_input_event_mask_ |= event_classes;
   input_event_mask_ &= ~(event_classes);
   RequestInputEventsHelper(event_classes);
   return ValidateRequestInputEvents(true, event_classes);
 }
 
-void PluginInstance::ClearInputEventRequest(PP_Instance instance,
-                                            uint32_t event_classes) {
+void PluginInstanceImpl::ClearInputEventRequest(PP_Instance instance,
+                                                uint32_t event_classes) {
   input_event_mask_ &= ~(event_classes);
   filtered_input_event_mask_ &= ~(event_classes);
   RequestInputEventsHelper(event_classes);
 }
 
-void PluginInstance::ZoomChanged(PP_Instance instance, double factor) {
+void PluginInstanceImpl::ZoomChanged(PP_Instance instance, double factor) {
   // We only want to tell the page to change its zoom if the whole page is the
   // plugin.  If we're in an iframe, then don't do anything.
   if (!IsFullPagePlugin())
     return;
   container()->zoomLevelChanged(WebView::zoomFactorToZoomLevel(factor));
 }
 
-void PluginInstance::ZoomLimitsChanged(PP_Instance instance,
-                                       double minimum_factor,
-                                       double maximium_factor) {
+void PluginInstanceImpl::ZoomLimitsChanged(PP_Instance instance,
+                                           double minimum_factor,
+                                           double maximium_factor) {
   if (minimum_factor > maximium_factor) {
     NOTREACHED();
     return;
   }
   delegate()->ZoomLimitsChanged(minimum_factor, maximium_factor);
 }
 
-void PluginInstance::PostMessage(PP_Instance instance, PP_Var message) {
+void PluginInstanceImpl::PostMessage(PP_Instance instance, PP_Var message) {
   message_channel_->PostMessageToJavaScript(message);
 }
 
-PP_Bool PluginInstance::SetCursor(PP_Instance instance,
-                                  PP_MouseCursor_Type type,
-                                  PP_Resource image,
-                                  const PP_Point* hot_spot) {
+PP_Bool PluginInstanceImpl::SetCursor(PP_Instance instance,
+                                      PP_MouseCursor_Type type,
+                                      PP_Resource image,
+                                      const PP_Point* hot_spot) {
   if (!ValidateSetCursorParams(type, image, hot_spot))
     return PP_FALSE;
 
   if (type != PP_MOUSECURSOR_TYPE_CUSTOM) {
     DoSetCursor(new WebCursorInfo(static_cast<WebCursorInfo::Type>(type)));
     return PP_TRUE;
   }
 
   EnterResourceNoLock<PPB_ImageData_API> enter(image, true);
   if (enter.failed())
@@ skipping 15 matching lines @@
   // image data gets freed.
   if (!bitmap->copyTo(&custom_cursor->customImage.getSkBitmap(),
                       bitmap->config())) {
     return PP_FALSE;
   }
 
   DoSetCursor(custom_cursor.release());
   return PP_TRUE;
 }
 
-int32_t PluginInstance::LockMouse(PP_Instance instance,
-                                  scoped_refptr<TrackedCallback> callback) {
+int32_t PluginInstanceImpl::LockMouse(PP_Instance instance,
+                                      scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(lock_mouse_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (delegate()->IsMouseLocked(this))
     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()) {
     // 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))
       return PP_ERROR_FAILED;
   }
 
   // Either mouselock succeeded or a Flash fullscreen is pending.
   lock_mouse_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
-void PluginInstance::UnlockMouse(PP_Instance instance) {
+void PluginInstanceImpl::UnlockMouse(PP_Instance instance) {
   delegate()->UnlockMouse(this);
 }
 
-void PluginInstance::SetTextInputType(PP_Instance instance,
-                                      PP_TextInput_Type type) {
+void PluginInstanceImpl::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);
 }
 
-void PluginInstance::UpdateCaretPosition(PP_Instance instance,
-                                         const PP_Rect& caret,
-                                         const PP_Rect& bounding_box) {
+void PluginInstanceImpl::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);
 }
 
-void PluginInstance::CancelCompositionText(PP_Instance instance) {
+void PluginInstanceImpl::CancelCompositionText(PP_Instance instance) {
   delegate()->PluginRequestedCancelComposition(this);
 }
 
-void PluginInstance::SelectionChanged(PP_Instance instance) {
+void PluginInstanceImpl::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(&PluginInstance::RequestSurroundingText,
+      base::Bind(&PluginInstanceImpl::RequestSurroundingText,
                  AsWeakPtr(),
                  static_cast<size_t>(kExtraCharsForTextInput)));
 }
 
-void PluginInstance::UpdateSurroundingText(PP_Instance instance,
-                                           const char* text,
-                                           uint32_t caret,
-                                           uint32_t anchor) {
+void PluginInstanceImpl::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);
 }
 
-PP_Var PluginInstance::ResolveRelativeToDocument(
+PP_Var PluginInstanceImpl::ResolveRelativeToDocument(
     PP_Instance instance,
     PP_Var relative,
     PP_URLComponents_Dev* components) {
   StringVar* relative_string = StringVar::FromPPVar(relative);
   if (!relative_string)
     return PP_MakeNull();
 
   WebElement plugin_element = container()->element();
   GURL document_url = plugin_element.document().baseURL();
   return ::ppapi::PPB_URLUtil_Shared::GenerateURLReturn(
       document_url.Resolve(relative_string->value()),
       components);
 }
 
-PP_Bool PluginInstance::DocumentCanRequest(PP_Instance instance, PP_Var url) {
+PP_Bool PluginInstanceImpl::DocumentCanRequest(PP_Instance instance,
+                                               PP_Var url) {
   StringVar* url_string = StringVar::FromPPVar(url);
   if (!url_string)
     return PP_FALSE;
 
   WebKit::WebSecurityOrigin security_origin;
   if (!SecurityOriginForInstance(instance, &security_origin))
     return PP_FALSE;
 
   GURL gurl(url_string->value());
   if (!gurl.is_valid())
     return PP_FALSE;
 
   return BoolToPPBool(security_origin.canRequest(gurl));
 }
 
-PP_Bool PluginInstance::DocumentCanAccessDocument(PP_Instance instance,
-                                                  PP_Instance target) {
+PP_Bool PluginInstanceImpl::DocumentCanAccessDocument(PP_Instance instance,
+                                                      PP_Instance target) {
   WebKit::WebSecurityOrigin our_origin;
   if (!SecurityOriginForInstance(instance, &our_origin))
     return PP_FALSE;
 
   WebKit::WebSecurityOrigin target_origin;
   if (!SecurityOriginForInstance(instance, &target_origin))
     return PP_FALSE;
 
   return BoolToPPBool(our_origin.canAccess(target_origin));
 }
 
-PP_Var PluginInstance::GetDocumentURL(PP_Instance instance,
-                                      PP_URLComponents_Dev* components) {
+PP_Var PluginInstanceImpl::GetDocumentURL(PP_Instance instance,
+                                          PP_URLComponents_Dev* components) {
   WebKit::WebDocument document = container()->element().document();
   return ::ppapi::PPB_URLUtil_Shared::GenerateURLReturn(document.url(),
                                                         components);
 }
 
-PP_Var PluginInstance::GetPluginInstanceURL(
+PP_Var PluginInstanceImpl::GetPluginInstanceURL(
     PP_Instance instance,
     PP_URLComponents_Dev* components) {
   return ::ppapi::PPB_URLUtil_Shared::GenerateURLReturn(plugin_url_,
                                                         components);
 }
 
-PP_ExternalPluginResult PluginInstance::ResetAsProxied(
+PP_ExternalPluginResult PluginInstanceImpl::ResetAsProxied(
     scoped_refptr<PluginModule> module) {
   // Save the original module and switch over to the new one now that this
   // plugin is using the IPC-based proxy.
   original_module_ = module_;
   module_ = module;
 
   // Don't send any messages to the plugin until DidCreate() has finished.
   message_channel_->QueueJavaScriptMessages();
 
   // For NaCl instances, remember the NaCl plugin instance interface, so we
@@ skipping 50 matching lines @@
     HandleDocumentLoad(nacl_document_response_);
     nacl_document_response_ = WebKit::WebURLResponse();
     // Replay any document load events we've received to the real loader.
     nacl_document_loader_->ReplayReceivedData(document_loader_);
     nacl_document_loader_.reset(NULL);
   }
 
   return PP_EXTERNAL_PLUGIN_OK;
 }
 
-bool PluginInstance::IsValidInstanceOf(PluginModule* module) {
+bool PluginInstanceImpl::IsValidInstanceOf(PluginModule* module) {
   DCHECK(module);
   return module == module_.get() ||
          module == original_module_.get();
 }
 
-NPP PluginInstance::instanceNPP() {
+NPP PluginInstanceImpl::instanceNPP() {
   return npp_.get();
 }
 
-v8::Isolate* PluginInstance::GetIsolate() const {
+v8::Isolate* PluginInstanceImpl::GetIsolate() const {
   return isolate_;
 }
 
 PluginInstance* PluginInstance::Get(PP_Instance instance_id) {
   return HostGlobals::Get()->GetInstance(instance_id);
 }
 
-::ppapi::VarTracker* PluginInstance::GetVarTracker() {
+content::RenderView* PluginInstanceImpl::GetRenderView() {
+  return render_view_;
+}
+
+WebKit::WebPluginContainer* PluginInstanceImpl::GetContainer() {
+  return container_;
+}
+
+::ppapi::VarTracker* PluginInstanceImpl::GetVarTracker() {
   return HostGlobals::Get()->GetVarTracker();
 }
 
-PP_Resource PluginInstance::CreateExternalFileReference(
+const GURL& PluginInstanceImpl::GetPluginURL() {
+  return plugin_url_;
+}
+
+base::FilePath PluginInstanceImpl::GetModulePath() {
+  return module_->path();
+}
+
+PP_Resource PluginInstanceImpl::CreateExternalFileReference(
     const base::FilePath& external_file_path) {
   webkit::ppapi::PPB_FileRef_Impl* ref =
       webkit::ppapi::PPB_FileRef_Impl::CreateExternal(
           pp_instance(), external_file_path, "");
   return ref->GetReference();
 }
 
-PP_Resource PluginInstance::CreateImage(gfx::ImageSkia* source_image,
-                                        float scale) {
+PP_Resource PluginInstanceImpl::CreateImage(gfx::ImageSkia* source_image,
+                                            float scale) {
   ui::ScaleFactor scale_factor = ui::GetScaleFactorFromScale(scale);
   gfx::ImageSkiaRep image_skia_rep = source_image->GetRepresentation(
       scale_factor);
 
   if (image_skia_rep.is_null() || image_skia_rep.scale_factor() != scale_factor)
     return 0;
 
   scoped_refptr<webkit::ppapi::PPB_ImageData_Impl> image_data(
       new webkit::ppapi::PPB_ImageData_Impl(
           pp_instance(),
@@ skipping 11 matching lines @@
     return 0;
 
   skia::PlatformCanvas* canvas = image_data->GetPlatformCanvas();
   // Note: Do not SkBitmap::copyTo the canvas bitmap directly because it will
   // ignore the allocated pixels in shared memory and re-allocate a new buffer.
   canvas->writePixels(image_skia_rep.sk_bitmap(), 0, 0);
 
   return image_data->GetReference();
 }
 
-base::FilePath PluginInstance::GetModulePath() {
-  return module_->path();
-}
-
-PP_ExternalPluginResult PluginInstance::SwitchToOutOfProcessProxy(
+PP_ExternalPluginResult PluginInstanceImpl::SwitchToOutOfProcessProxy(
     const base::FilePath& file_path,
     ::ppapi::PpapiPermissions permissions,
     const IPC::ChannelHandle& channel_handle,
     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<webkit::ppapi::PluginModule> external_plugin_module(
       module_->CreateModuleForExternalPluginInstance());
 
   content::RendererPpapiHost* renderer_ppapi_host =
       delegate_->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 PluginInstance::DoSetCursor(WebCursorInfo* cursor) {
+void PluginInstanceImpl::SetAlwaysOnTop(bool on_top) {
+  always_on_top_ = on_top;
+}
+
+void PluginInstanceImpl::DoSetCursor(WebCursorInfo* cursor) {
   cursor_.reset(cursor);
   if (fullscreen_container_) {
     fullscreen_container_->DidChangeCursor(*cursor);
   } else {
     delegate()->DidChangeCursor(this, *cursor);
   }
 }
 
-bool PluginInstance::CanAccessMainFrame() const {
+bool PluginInstanceImpl::IsFullPagePlugin() {
+  WebFrame* frame = container()->element().document().frame();
+  return frame->view()->mainFrame()->document().isPluginDocument();
+}
+
+void PluginInstanceImpl::FlashSetFullscreen(bool fullscreen,
+                                            bool delay_report) {
+  TRACE_EVENT0("ppapi", "PluginInstanceImpl::FlashSetFullscreen");
+  // Keep a reference on the stack. See NOTE above.
+  scoped_refptr<PluginInstanceImpl> ref(this);
+
+  // We check whether we are trying to switch to the state we're already going
+  // to (i.e. if we're already switching to fullscreen but the fullscreen
+  // container isn't ready yet, don't do anything more).
+  if (fullscreen == FlashIsFullscreenOrPending())
+    return;
+
+  // Unbind current 2D or 3D graphics context.
+  VLOG(1) << "Setting fullscreen to " << (fullscreen ? "on" : "off");
+  if (fullscreen) {
+    DCHECK(!fullscreen_container_);
+    fullscreen_container_ = delegate_->CreateFullscreenContainer(this);
+    UpdateLayer();
+  } else {
+    DCHECK(fullscreen_container_);
+    fullscreen_container_->Destroy();
+    fullscreen_container_ = NULL;
+    UpdateFlashFullscreenState(false);
+    if (!delay_report) {
+      ReportGeometry();
+    } else {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&PluginInstanceImpl::ReportGeometry, this));
+    }
+  }
+}
+
+bool PluginInstanceImpl::IsRectTopmost(const gfx::Rect& rect) {
+  if (flash_fullscreen_)
+    return true;
+
+  return container_->isRectTopmost(rect);
+}
+
+int32_t PluginInstanceImpl::Navigate(const ::ppapi::URLRequestInfoData& request,
+                                     const char* target,
+                                     bool from_user_action) {
+  if (!container_)
+    return PP_ERROR_FAILED;
+
+  WebDocument document = container_->element().document();
+  WebFrame* frame = document.frame();
+  if (!frame)
+    return PP_ERROR_FAILED;
+
+  ::ppapi::URLRequestInfoData completed_request = request;
+
+  WebURLRequest web_request;
+  if (!CreateWebURLRequest(&completed_request, frame, &web_request))
+    return PP_ERROR_FAILED;
+  web_request.setFirstPartyForCookies(document.firstPartyForCookies());
+  web_request.setHasUserGesture(from_user_action);
+
+  GURL gurl(web_request.url());
+  if (gurl.SchemeIs("javascript")) {
+    // In imitation of the NPAPI implementation, only |target_frame == frame| is
+    // allowed for security reasons.
+    WebFrame* target_frame =
+        frame->view()->findFrameByName(WebString::fromUTF8(target), frame);
+    if (target_frame != frame)
+      return PP_ERROR_NOACCESS;
+
+    // TODO(viettrungluu): NPAPI sends the result back to the plugin -- do we
+    // need that?
+    WebString result = container_->executeScriptURL(gurl, from_user_action);
+    return result.isNull() ? PP_ERROR_FAILED : PP_OK;
+  }
+
+  // Only GETs and POSTs are supported.
+  if (web_request.httpMethod() != "GET" &&
+      web_request.httpMethod() != "POST")
+    return PP_ERROR_BADARGUMENT;
+
+  WebString target_str = WebString::fromUTF8(target);
+  container_->loadFrameRequest(web_request, target_str, false, NULL);
+  return PP_OK;
+}
+
+bool PluginInstanceImpl::CanAccessMainFrame() const {
   if (!container_)
     return false;
   WebKit::WebDocument containing_document = container_->element().document();
 
   if (!containing_document.frame() ||
       !containing_document.frame()->view() ||
       !containing_document.frame()->view()->mainFrame()) {
     return false;
   }
   WebKit::WebDocument main_document =
       containing_document.frame()->view()->mainFrame()->document();
 
   return containing_document.securityOrigin().canAccess(
       main_document.securityOrigin());
 }
 
-void PluginInstance::KeepSizeAttributesBeforeFullscreen() {
+void PluginInstanceImpl::KeepSizeAttributesBeforeFullscreen() {
   WebElement element = container_->element();
   width_before_fullscreen_ = element.getAttribute(WebString::fromUTF8(kWidth));
   height_before_fullscreen_ =
       element.getAttribute(WebString::fromUTF8(kHeight));
   border_before_fullscreen_ =
       element.getAttribute(WebString::fromUTF8(kBorder));
   style_before_fullscreen_ = element.getAttribute(WebString::fromUTF8(kStyle));
 }
 
-void PluginInstance::SetSizeAttributesForFullscreen() {
+void PluginInstanceImpl::SetSizeAttributesForFullscreen() {
   screen_size_for_fullscreen_ = delegate()->GetScreenSize();
   std::string width = StringPrintf("%d", screen_size_for_fullscreen_.width());
   std::string height = StringPrintf("%d", screen_size_for_fullscreen_.height());
 
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), WebString::fromUTF8(width));
   element.setAttribute(WebString::fromUTF8(kHeight),
                        WebString::fromUTF8(height));
   element.setAttribute(WebString::fromUTF8(kBorder), WebString::fromUTF8("0"));
 
   // There should be no style settings that matter in fullscreen mode,
   // so just replace them instead of appending.
   // NOTE: "position: fixed" and "display: block" reset the plugin and
   // using %% settings might not work without them (e.g. if the plugin is a
   // child of a container element).
   std::string style;
   style += StringPrintf("width: %s !important; ", width.c_str());
   style += StringPrintf("height: %s !important; ", height.c_str());
   style += "margin: 0 !important; padding: 0 !important; border: 0 !important";
   container_->element().setAttribute(kStyle, WebString::fromUTF8(style));
 }
 
-void PluginInstance::ResetSizeAttributesAfterFullscreen() {
+void PluginInstanceImpl::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_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit