Change the DidChangeView update to take a new ViewChanged resource.

webkit/plugins/ppapi/ppapi_plugin_instance.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/dev/ppb_find_dev.h"
 #include "ppapi/c/dev/ppb_zoom_dev.h"
 #include "ppapi/c/dev/ppp_find_dev.h"
 #include "ppapi/c/dev/ppp_selection_dev.h"
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/ppp_mouse_lock.h"
 #include "ppapi/c/private/ppp_instance_private.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
+#include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
+#include "ppapi/shared_impl/resource.h"
+#include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_buffer_api.h"
 #include "printing/units.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCompositionUnderline.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/event_conversion.h"
 #include "webkit/plugins/ppapi/fullscreen_container.h"
+#include "webkit/plugins/ppapi/gfx_conversion.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/message_channel.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_2d_impl.h"
 #include "webkit/plugins/ppapi/ppb_graphics_3d_impl.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 #include "webkit/plugins/ppapi/ppb_url_loader_impl.h"
@@ skipping 19 matching lines @@
 #include "base/metrics/histogram.h"
 #include "skia/ext/platform_canvas.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/gdi_util.h"
 #endif
 
 using base::StringPrintf;
 using ppapi::InputEventData;
 using ppapi::PPB_InputEvent_Shared;
 using ppapi::PpapiGlobals;
+using ppapi::PPB_View_Shared;
+using ppapi::ScopedPPResource;
 using ppapi::StringVar;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Buffer_API;
 using ppapi::thunk::PPB_Graphics2D_API;
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::thunk::PPB_Instance_FunctionAPI;
 using ppapi::Var;
+using ppapi::ViewData;
 using WebKit::WebBindings;
 using WebKit::WebCanvas;
 using WebKit::WebConsoleMessage;
 using WebKit::WebCursorInfo;
 using WebKit::WebDocument;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebPluginContainer;
 using WebKit::WebString;
@@ skipping 100 matching lines @@
 COMPILE_ASSERT_MATCHING_ENUM(TypeCopy, PP_CURSORTYPE_COPY);
 COMPILE_ASSERT_MATCHING_ENUM(TypeNone, PP_CURSORTYPE_NONE);
 COMPILE_ASSERT_MATCHING_ENUM(TypeNotAllowed, PP_CURSORTYPE_NOTALLOWED);
 COMPILE_ASSERT_MATCHING_ENUM(TypeZoomIn, PP_CURSORTYPE_ZOOMIN);
 COMPILE_ASSERT_MATCHING_ENUM(TypeZoomOut, PP_CURSORTYPE_ZOOMOUT);
 COMPILE_ASSERT_MATCHING_ENUM(TypeGrab, PP_CURSORTYPE_GRAB);
 COMPILE_ASSERT_MATCHING_ENUM(TypeGrabbing, PP_CURSORTYPE_GRABBING);
 // Do not assert WebCursorInfo::TypeCustom == PP_CURSORTYPE_CUSTOM;
 // PP_CURSORTYPE_CUSTOM is pinned to allow new cursor types.
 
-void RectToPPRect(const gfx::Rect& input, PP_Rect* output) {
-  *output = PP_MakeRectFromXYWH(input.x(), input.y(),
-                                input.width(), input.height());
-}
-
 // 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);
   if (!instance)
     return false;
 
   WebElement plugin_element = instance->container()->element();
   *security_origin = plugin_element.document().securityOrigin();
   return true;
 }
 
 }  // namespace
 
 // static
 PluginInstance* PluginInstance::Create1_0(PluginDelegate* delegate,
                                           PluginModule* module,
                                           const void* ppp_instance_if_1_0) {
   const PPP_Instance_1_0* instance =
       static_cast<const PPP_Instance_1_0*>(ppp_instance_if_1_0);
   return new PluginInstance(
       delegate,
       module,
       new ::ppapi::PPP_Instance_Combined(*instance));
 }
 
+// static
+PluginInstance* PluginInstance::Create1_1(PluginDelegate* delegate,
+                                          PluginModule* module,
+                                          const void* ppp_instance_if_1_1) {
+  const PPP_Instance_1_1* instance =
+      static_cast<const PPP_Instance_1_1*>(ppp_instance_if_1_1);
+  return new PluginInstance(
+      delegate,
+      module,
+      new ::ppapi::PPP_Instance_Combined(*instance));
+}
+
 PluginInstance::PluginInstance(
     PluginDelegate* delegate,
     PluginModule* module,
     ::ppapi::PPP_Instance_Combined* instance_interface)
     : delegate_(delegate),
       module_(module),
       instance_interface_(instance_interface),
       pp_instance_(0),
       container_(NULL),
       full_frame_(false),
-      sent_did_change_view_(false),
+      sent_initial_did_change_view_(false),
+      suppress_did_change_view_(false),
       has_webkit_focus_(false),
       has_content_area_focus_(false),
       find_identifier_(-1),
       plugin_find_interface_(NULL),
       plugin_messaging_interface_(NULL),
       plugin_mouse_lock_interface_(NULL),
       plugin_input_event_interface_(NULL),
       plugin_private_interface_(NULL),
       plugin_pdf_interface_(NULL),
       plugin_selection_interface_(NULL),
       plugin_zoom_interface_(NULL),
       checked_for_plugin_input_event_interface_(false),
       checked_for_plugin_messaging_interface_(false),
       plugin_print_interface_(NULL),
       plugin_graphics_3d_interface_(NULL),
       always_on_top_(false),
       fullscreen_container_(NULL),
       flash_fullscreen_(false),
       desired_fullscreen_state_(false),
-      fullscreen_(false),
       message_channel_(NULL),
       sad_plugin_(NULL),
       input_event_mask_(0),
       filtered_input_event_mask_(0),
       text_input_type_(kPluginDefaultTextInputType),
       text_input_caret_(0, 0, 0, 0),
       text_input_caret_bounds_(0, 0, 0, 0),
       text_input_caret_set_(false),
       lock_mouse_callback_(PP_BlockUntilComplete()) {
   pp_instance_ = HostGlobals::Get()->AddInstance(this);
@@ skipping 64 matching lines @@
     bound_graphics_2d->Paint(canvas, plugin_rect, paint_rect);
 }
 
 void PluginInstance::InvalidateRect(const gfx::Rect& rect) {
   if (fullscreen_container_) {
     if (rect.IsEmpty())
       fullscreen_container_->Invalidate();
     else
       fullscreen_container_->InvalidateRect(rect);
   } else {
-    if (!container_ || position_.IsEmpty())
+    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) {
   if (fullscreen_container_) {
@@ skipping 241 matching lines @@
 }
 
 bool PluginInstance::IsPluginAcceptingCompositionEvents() const {
   return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_IME) ||
       (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
 }
 
 gfx::Rect PluginInstance::GetCaretBounds() const {
   if (!text_input_caret_set_) {
     // If it is never set by the plugin, use the bottom left corner.
-    return gfx::Rect(position().x(), position().y()+position().height(), 0, 0);
+    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(position().origin());
+  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");
 
   if (WebInputEvent::isMouseEventType(event.type))
     delegate()->DidReceiveMouseEvent(this);
 
@@ skipping 60 matching lines @@
 void PluginInstance::ViewChanged(const gfx::Rect& position,
                                  const gfx::Rect& clip) {
   // 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;
 
-  // Don't notify the plugin if we've already sent these same params before.
-  if (sent_did_change_view_ && position == position_ && new_clip == clip_)
-    return;
+  ViewData previous_view = view_data_;
 
-  if (desired_fullscreen_state_ || fullscreen_) {
+  view_data_.rect = PP_FromGfxRect(position);
+  view_data_.clip_rect = PP_FromGfxRect(clip);
+
+  if (desired_fullscreen_state_ || view_data_.is_fullscreen) {
     WebElement element = container_->element();
     WebDocument document = element.document();
     bool is_fullscreen_element = (element == document.fullScreenElement());
-    if (!fullscreen_ && desired_fullscreen_state_ &&
+    if (!view_data_.is_fullscreen && desired_fullscreen_state_ &&
         delegate()->IsInFullscreenMode() && is_fullscreen_element) {
       // Entered fullscreen. Only possible via SetFullscreen().
-      fullscreen_ = true;
-    } else if (fullscreen_ && !is_fullscreen_element) {
+      view_data_.is_fullscreen = true;
+    } else if (view_data_.is_fullscreen && !is_fullscreen_element) {
       // Exited fullscreen. Possible via SetFullscreen() or F11/link,
       // so desired_fullscreen_state might be out-of-date.
       desired_fullscreen_state_ = false;
-      fullscreen_ = false;
+      view_data_.is_fullscreen = false;
+
+      // This operation will cause the plugin to re-layout which will send more
+      // DidChangeView updates. Schedule an asynchronous update and suppress
+      // notifications until that completes to avoid sending intermediate sizes
+      // to the plugins.
+      ScheduleAsyncDidChangeView(previous_view);
+
       // Reset the size attributes that we hacked to fill in the screen and
       // retrigger ViewChanged. Make sure we don't forward duplicates of
       // this view to the plugin.
       ResetSizeAttributesAfterFullscreen();
-      SetSentDidChangeView(position, new_clip);
-      MessageLoop::current()->PostTask(
-          FROM_HERE, base::Bind(&PluginInstance::ReportGeometry, this));
       return;
     }
   }
 
-  SetSentDidChangeView(position, new_clip);
   flash_fullscreen_ = (fullscreen_container_ != NULL);
-
-  PP_Rect pp_position, pp_clip;
-  RectToPPRect(position_, &pp_position);
-  RectToPPRect(clip_, &pp_clip);
-  instance_interface_->DidChangeView(pp_instance(), &pp_position, &pp_clip);
+  SendDidChangeView(previous_view);
 }
 
 void PluginInstance::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) {
     delegate()->PluginFocusChanged(this, PluginHasFocus());
@@ skipping 37 matching lines @@
     gfx::Rect* clip) {
   if (!always_on_top_)
     return false;
   if (!GetBoundGraphics2D() || !GetBoundGraphics2D()->is_always_opaque())
     return false;
 
   // We specifically want to compare against the area covered by the backing
   // store when seeing if we cover the given paint bounds, since the backing
   // store could be smaller than the declared plugin area.
   PPB_ImageData_Impl* image_data = GetBoundGraphics2D()->image_data();
-  gfx::Rect plugin_backing_store_rect(position_.origin(),
-                                      gfx::Size(image_data->width(),
-                                                image_data->height()));
-  gfx::Rect clip_page(clip_);
-  clip_page.Offset(position_.origin());
+  gfx::Rect plugin_backing_store_rect(
+      PP_ToGfxPoint(view_data_.rect.point),
+      gfx::Size(image_data->width(), image_data->height()));
+
+  gfx::Rect clip_page = PP_ToGfxRect(view_data_.clip_rect);
+  clip_page.Offset(PP_ToGfxPoint(view_data_.rect.point));
   gfx::Rect plugin_paint_rect = plugin_backing_store_rect.Intersect(clip_page);
   if (!plugin_paint_rect.Contains(paint_bounds))
     return false;
 
   *dib = image_data->platform_image()->GetTransportDIB();
   *location = plugin_backing_store_rect;
   *clip = clip_page;
   return true;
 }
 
@@ skipping 156 matching lines @@
             PPP_ZOOM_DEV_INTERFACE));
   }
 
   return !!plugin_zoom_interface_;
 }
 
 bool PluginInstance::PluginHasFocus() const {
   return has_webkit_focus_ && has_content_area_focus_;
 }
 
+void PluginInstance::ScheduleAsyncDidChangeView(
+    const ::ppapi::ViewData& previous_view) {
+  if (suppress_did_change_view_)
+    return;  // Already scheduled.
+  suppress_did_change_view_ = true;
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&PluginInstance::SendAsyncDidChangeView,
+                            this, previous_view));
+}
+
+void PluginInstance::SendAsyncDidChangeView(const ViewData& previous_view) {
+  DCHECK(suppress_did_change_view_);
+  suppress_did_change_view_ = false;
+  SendDidChangeView(previous_view);
+}
+
+void PluginInstance::SendDidChangeView(const ViewData& previous_view) {
+  if (suppress_did_change_view_ ||
+      (sent_initial_did_change_view_ && previous_view.Equals(view_data_)))
+    return;  // Nothing to update.
+
+  sent_initial_did_change_view_ = true;
+  ScopedPPResource resource(
+      ScopedPPResource::PassRef(),
+      (new PPB_View_Shared(PPB_View_Shared::InitAsImpl(),
+                           pp_instance(), view_data_))->GetReference());
+
+  instance_interface_->DidChangeView(pp_instance(), resource,
+                                     &view_data_.rect,
+                                     &view_data_.clip_rect);
+}
+
 void PluginInstance::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(
     PP_PrintOutputFormat_Dev* format) {
@@ skipping 32 matching lines @@
   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;
-  RectToPPRect(printable_area, &print_settings.printable_area);
+  print_settings.printable_area = PP_FromGfxRect(printable_area);
   print_settings.dpi = printer_dpi;
   print_settings.orientation = PP_PRINTORIENTATION_NORMAL;
   print_settings.grayscale = PP_FALSE;
   print_settings.format = format;
   num_pages = plugin_print_interface_->Begin(pp_instance(),
                                              &print_settings);
   if (!num_pages)
     return 0;
   current_print_settings_ = print_settings;
 #if defined(USE_SKIA)
@@ skipping 85 matching lines @@
 
   // 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.
-  if (fullscreen_ != desired_fullscreen_state_)
+  if (view_data_.is_fullscreen != desired_fullscreen_state_)
     return false;
 
   // The browser will allow us to go into fullscreen mode only when processing
   // a user gesture. This is guaranteed to work with in-process plugins and
   // out-of-process syncronous proxies, but might be an issue with Flash when
   // it switches over from PPB_FlashFullscreen.
   // TODO(polina, bbudge): make this work with asynchronous proxies.
   WebFrame* frame = container_->element().document().frame();
   if (fullscreen && !frame->isProcessingUserGesture())
     return false;
@@ skipping 410 matching lines @@
 void PluginInstance::SimulateInputEvent(const InputEventData& input_event) {
   WebView* web_view = container()->element().document().frame()->view();
   if (!web_view) {
     NOTREACHED();
     return;
   }
 
   std::vector<linked_ptr<WebInputEvent> > events =
       CreateSimulatedWebInputEvents(
           input_event,
-          position().x() + position().width() / 2,
-          position().y() + position().height() / 2);
+          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());
   }
 }
 
 PPB_Instance_FunctionAPI* PluginInstance::AsPPB_Instance_FunctionAPI() {
   return this;
 }
 
@@ skipping 11 matching lines @@
   // Special-case clearing the current device.
   if (!device) {
     setBackingTextureId(0);
     InvalidateRect(gfx::Rect());
     return PP_TRUE;
   }
 
   // Refuse to bind if in transition to fullscreen with PPB_FlashFullscreen or
   // to/from fullscreen with PPB_Fullscreen.
   if ((fullscreen_container_ && !flash_fullscreen_) ||
-      desired_fullscreen_state_ != fullscreen_)
+      desired_fullscreen_state_ != view_data_.is_fullscreen)
     return PP_FALSE;
 
   EnterResourceNoLock<PPB_Graphics2D_API> enter_2d(device, false);
   PPB_Graphics2D_Impl* graphics_2d = enter_2d.succeeded() ?
       static_cast<PPB_Graphics2D_Impl*>(enter_2d.object()) : NULL;
   EnterResourceNoLock<PPB_Graphics3D_API> enter_3d(device, false);
   PPB_Graphics3D_Impl* graphics_3d = enter_3d.succeeded() ?
       static_cast<PPB_Graphics3D_Impl*>(enter_3d.object()) : NULL;
 
   if (graphics_2d) {
@@ skipping 20 matching lines @@
     return PP_FALSE;
   }
 
   return PP_TRUE;
 }
 
 PP_Bool PluginInstance::IsFullFrame(PP_Instance instance) {
   return PP_FromBool(full_frame());
 }
 
+const ViewData* PluginInstance::GetViewData(PP_Instance instance) {
+  return &view_data_;
+}
+
 PP_Var PluginInstance::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());
 }
@@ skipping 103 matching lines @@
   delegate_->NumberOfFindResultsChanged(find_identifier_, total,
                                         PP_ToBool(final_result));
 }
 
 void PluginInstance::SelectedFindResultChanged(PP_Instance instance,
                                                int32_t index) {
   DCHECK_NE(find_identifier_, -1);
   delegate_->SelectedFindResultChanged(find_identifier_, index);
 }
 
-PP_Bool PluginInstance::IsFullscreen(PP_Instance instance) {
-  return PP_FromBool(fullscreen_);
-}
-
 PP_Bool PluginInstance::FlashIsFullscreen(PP_Instance instance) {
   return PP_FromBool(flash_fullscreen_);
 }
 
 PP_Bool PluginInstance::SetFullscreen(PP_Instance instance,
                                       PP_Bool fullscreen) {
   return PP_FromBool(SetFullscreen(PP_ToBool(fullscreen)));
 }
 
 PP_Bool PluginInstance::FlashSetFullscreen(PP_Instance instance,
@@ skipping 154 matching lines @@
       !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::SetSentDidChangeView(const gfx::Rect& position,
-                                          const gfx::Rect& clip) {
-  sent_did_change_view_ = true;
-  position_ = position;
-  clip_ = clip;
-}
-
 void PluginInstance::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));
 }
 
@@ skipping 24 matching lines @@
   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