Revert 76840 - Removed GPU plugin....

chrome/renderer/webplugin_delegate_pepper.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.
 
 #define PEPPER_APIS_ENABLED 1
 
 #include "chrome/renderer/webplugin_delegate_pepper.h"
 
 #include <string>
 #include <vector>
@@ skipping 45 matching lines @@
 #elif defined(OS_LINUX)
 #include "chrome/renderer/renderer_sandbox_support_linux.h"
 #include "printing/pdf_ps_metafile_cairo.h"
 #elif defined(OS_WIN)
 #include "printing/units.h"
 #include "skia/ext/vector_platform_device.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/gdi_util.h"
 #endif
 
+#if defined(ENABLE_GPU)
+#include "webkit/plugins/npapi/plugin_constants_win.h"
+#endif
+
+#if defined(ENABLE_GPU)
+using gpu::Buffer;
+#endif
+
 using webkit::npapi::WebPlugin;
 using webkit::npapi::WebPluginDelegate;
 using webkit::npapi::WebPluginResourceClient;
 using WebKit::WebCursorInfo;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
 namespace {
 
 // Implementation artifacts for a context
 struct Device2DImpl {
   TransportDIB* dib;
 };
 
+struct Device3DImpl {
+#if defined(ENABLE_GPU)
+  gpu::CommandBuffer* command_buffer;
+#endif
+  bool dynamically_created;
+};
+
+const int32 kDefaultCommandBufferSize = 1024 * 1024;
+
 }  // namespace
 
 static const float kPointsPerInch = 72.0;
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*RenderPDFPageToDCProc)(
     const unsigned char* pdf_buffer, int buffer_size, int page_number, HDC dc,
     int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y,
     int bounds_width, int bounds_height, bool fit_to_bounds,
@@ skipping 81 matching lines @@
 
     window_.window = NULL;
     instance_->NPP_SetWindow(&window_);
 
     instance_->NPP_Destroy();
 
     instance_->set_web_plugin(NULL);
 
     instance_ = 0;
   }
+
+  // Destroy the nested GPU plugin only after first destroying the underlying
+  // Pepper plugin. This is so the Pepper plugin does not attempt to issue
+  // rendering commands after the GPU plugin has stopped processing them and
+  // responding to them.
+  if (nested_delegate_) {
+#if defined(ENABLE_GPU)
+    if (command_buffer_) {
+      nested_delegate_->DestroyCommandBuffer(command_buffer_);
+      command_buffer_ = NULL;
+    }
+#endif
+
+    nested_delegate_->PluginDestroyed();
+    nested_delegate_ = NULL;
+  }
 }
 
 void WebPluginDelegatePepper::UpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect) {
   // Only resend to the instance if the geometry has changed.
   if (window_rect == window_rect_ && clip_rect == clip_rect_)
     return;
 
   clip_rect_ = clip_rect;
   cutout_rects_.clear();
 
   if (window_rect_ == window_rect)
     return;
   window_rect_ = window_rect;
 
   // TODO(brettw) figure out how to tell the plugin that the size changed and it
   // needs to repaint?
   SkBitmap new_committed;
   new_committed.setConfig(SkBitmap::kARGB_8888_Config,
                           window_rect_.width(), window_rect_.height());
   new_committed.allocPixels();
   committed_bitmap_ = new_committed;
 
+  // Forward the new geometry to the nested plugin instance.
+  if (nested_delegate_)
+    nested_delegate_->UpdateGeometry(window_rect, clip_rect);
+
+#if defined(ENABLE_GPU)
+#if defined(OS_MACOSX)
+  // Send the new window size to the command buffer service code so it
+  // can allocate a new backing store. The handle to the new backing
+  // store is sent back to the browser asynchronously.
+  if (command_buffer_) {
+    command_buffer_->SetWindowSize(window_rect_.size());
+  }
+#endif  // OS_MACOSX
+#endif  // ENABLE_GPU
+
   if (!instance())
     return;
 
   ForwardSetWindow();
 }
 
 NPObject* WebPluginDelegatePepper::GetPluginScriptableObject() {
   return instance_->GetPluginScriptableObject();
 }
 
@@ skipping 295 matching lines @@
 
 NPError WebPluginDelegatePepper::Device2DInitializeContext(
     const NPDeviceContext2DConfig* config,
     NPDeviceContext2D* context) {
 
   if (!render_view_) {
     return NPERR_GENERIC_ERROR;
   }
 
   // This is a windowless plugin, so set it to have no handle. Defer this
-  // until we know the plugin will use the 2D device.
+  // until we know the plugin will use the 2D device. If it uses the 3D device
+  // it will have a window handle.
   plugin_->SetWindow(gfx::kNullPluginWindow);
 
   scoped_ptr<Graphics2DDeviceContext> g2d(new Graphics2DDeviceContext(this));
   NPError status = g2d->Initialize(window_rect_, config, context);
   if (NPERR_NO_ERROR == status) {
     context->reserved = reinterpret_cast<void *>(
         graphic2d_contexts_.Add(g2d.release()));
   }
   return status;
 }
@@ skipping 80 matching lines @@
 
 NPError WebPluginDelegatePepper::Device3DQueryConfig(
     const NPDeviceContext3DConfig* request,
     NPDeviceContext3DConfig* obtain) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DInitializeContext(
     const NPDeviceContext3DConfig* config,
     NPDeviceContext3D* context) {
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+#if defined(ENABLE_GPU)
+  // Check to see if the GPU plugin is already initialized and fail if so.
+  if (nested_delegate_)
+    return NPERR_GENERIC_ERROR;
+
+  // Create an instance of the GPU plugin that is responsible for 3D
+  // rendering.
+  nested_delegate_ = new WebPluginDelegateProxy(
+      "application/vnd.google.chrome.gpu-plugin", render_view_);
+
+  // TODO(apatrick): should the GPU plugin be attached to plugin_?
+  if (nested_delegate_->Initialize(GURL(),
+                                   std::vector<std::string>(),
+                                   std::vector<std::string>(),
+                                   plugin_,
+                                   false)) {
+    plugin_->SetAcceptsInputEvents(true);
+
+    // Ensure the window has the correct size before initializing the
+    // command buffer.
+    nested_delegate_->UpdateGeometry(window_rect_, clip_rect_);
+
+    // Ask the GPU plugin to create a command buffer and return a proxy.
+    command_buffer_ = nested_delegate_->CreateCommandBuffer();
+    if (command_buffer_) {
+      // Initialize the proxy command buffer.
+      if (command_buffer_->Initialize(config->commandBufferSize)) {
+        // Get the initial command buffer state.
+        gpu::CommandBuffer::State state = command_buffer_->GetState();
+
+        // Initialize the 3D context.
+        context->reserved = NULL;
+        context->waitForProgress = true;
+        Buffer ring_buffer = command_buffer_->GetRingBuffer();
+        context->commandBuffer = ring_buffer.ptr;
+        context->commandBufferSize = state.num_entries;
+        context->repaintCallback = NULL;
+        Synchronize3DContext(context, state);
+
+        ScheduleHandleRepaint(instance_->npp(), context);
+
+#if defined(OS_MACOSX)
+        command_buffer_->SetWindowSize(window_rect_.size());
+#endif  // OS_MACOSX
+
+        // Make sure the nested delegate shows up in the right place
+        // on the page.
+        SendNestedDelegateGeometryToBrowser(window_rect_, clip_rect_);
+
+        // Save the implementation information (the CommandBuffer).
+        Device3DImpl* impl = new Device3DImpl;
+        impl->command_buffer = command_buffer_;
+        impl->dynamically_created = false;
+        context->reserved = impl;
+
+        return NPERR_NO_ERROR;
+      }
+
+      nested_delegate_->DestroyCommandBuffer(command_buffer_);
+      command_buffer_ = NULL;
+    }
+  }
+
+  nested_delegate_->PluginDestroyed();
+  nested_delegate_ = NULL;
+#endif  // ENABLE_GPU
+
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DSetStateContext(
     NPDeviceContext3D* context,
     int32 state,
     intptr_t value) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DGetStateContext(
     NPDeviceContext3D* context,
     int32 state,
     intptr_t* value) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DFlushContext(
     NPP id,
     NPDeviceContext3D* context,
     NPDeviceFlushContextCallbackPtr callback,
     void* user_data) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+#if defined(ENABLE_GPU)
+  gpu::CommandBuffer::State state;
+
+  if (context->waitForProgress) {
+    if (callback) {
+      command_buffer_->AsyncFlush(
+          context->putOffset,
+          method_factory3d_.NewRunnableMethod(
+              &WebPluginDelegatePepper::Device3DUpdateState,
+              id,
+              context,
+              callback,
+              user_data));
+    } else {
+      state = command_buffer_->FlushSync(context->putOffset);
+      Synchronize3DContext(context, state);
+    }
+  } else {
+    if (callback) {
+      command_buffer_->AsyncGetState(
+          method_factory3d_.NewRunnableMethod(
+              &WebPluginDelegatePepper::Device3DUpdateState,
+              id,
+              context,
+              callback,
+              user_data));
+    } else {
+      state = command_buffer_->GetState();
+      Synchronize3DContext(context, state);
+    }
+  }
+#endif  // ENABLE_GPU
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DDestroyContext(
     NPDeviceContext3D* context) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+#if defined(ENABLE_GPU)
+  // Prevent any async flush callbacks from being invoked after the context
+  // has been destroyed.
+  method_factory3d_.RevokeAll();
+
+  // TODO(apatrick): this will be much simpler when we switch to the new device
+  // API. There should be no need for the Device3DImpl and the context will
+  // always be destroyed dynamically.
+  Device3DImpl* impl = static_cast<Device3DImpl*>(context->reserved);
+  bool dynamically_created = impl->dynamically_created;
+  delete impl;
+  context->reserved = NULL;
+  if (dynamically_created) {
+    delete context;
+  }
+
+  if (nested_delegate_) {
+    if (command_buffer_) {
+      nested_delegate_->DestroyCommandBuffer(command_buffer_);
+      command_buffer_ = NULL;
+    }
+
+    nested_delegate_->PluginDestroyed();
+    nested_delegate_ = NULL;
+  }
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DCreateBuffer(
     NPDeviceContext3D* context,
     size_t size,
     int32* id) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+#if defined(ENABLE_GPU)
+  *id = command_buffer_->CreateTransferBuffer(size);
+  if (*id < 0)
+    return NPERR_GENERIC_ERROR;
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DDestroyBuffer(
     NPDeviceContext3D* context,
     int32 id) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+#if defined(ENABLE_GPU)
+  command_buffer_->DestroyTransferBuffer(id);
+#endif  // ENABLE_GPU
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DMapBuffer(
     NPDeviceContext3D* context,
     int32 id,
     NPDeviceBuffer* np_buffer) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+#if defined(ENABLE_GPU)
+  Buffer gpu_buffer;
+  if (id == NP3DCommandBufferId) {
+    gpu_buffer = command_buffer_->GetRingBuffer();
+  } else {
+    gpu_buffer = command_buffer_->GetTransferBuffer(id);
+  }
+
+  np_buffer->ptr = gpu_buffer.ptr;
+  np_buffer->size = gpu_buffer.size;
+  if (!np_buffer->ptr)
+    return NPERR_GENERIC_ERROR;
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DGetNumConfigs(int32* num_configs) {
-  return NPERR_GENERIC_ERROR;
+  if (!num_configs)
+    return NPERR_GENERIC_ERROR;
+
+  *num_configs = 1;
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DGetConfigAttribs(
     int32 config,
     int32* attrib_list) {
-  return NPERR_GENERIC_ERROR;
+  // Only one config available currently.
+  if (config != 0)
+    return NPERR_GENERIC_ERROR;
+
+  if (attrib_list) {
+    for (int32* attrib_pair = attrib_list; *attrib_pair; attrib_pair += 2) {
+      switch (attrib_pair[0]) {
+        case NP3DAttrib_BufferSize:
+          attrib_pair[1] = 32;
+          break;
+        case NP3DAttrib_AlphaSize:
+        case NP3DAttrib_BlueSize:
+        case NP3DAttrib_GreenSize:
+        case NP3DAttrib_RedSize:
+          attrib_pair[1] = 8;
+          break;
+        case NP3DAttrib_DepthSize:
+          attrib_pair[1] = 24;
+          break;
+        case NP3DAttrib_StencilSize:
+          attrib_pair[1] = 8;
+          break;
+        case NP3DAttrib_SurfaceType:
+          attrib_pair[1] = 0;
+          break;
+        default:
+          return NPERR_GENERIC_ERROR;
+      }
+    }
+  }
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DCreateContext(
     int32 config,
     const int32* attrib_list,
     NPDeviceContext3D** context) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+  // Only one config available currently.
+  if (config != 0)
+    return NPERR_GENERIC_ERROR;
+
+  // For now, just use the old API to initialize the context.
+  NPDeviceContext3DConfig old_config;
+  old_config.commandBufferSize = kDefaultCommandBufferSize;
+  if (attrib_list) {
+    for (const int32* attrib_pair = attrib_list; *attrib_pair;
+         attrib_pair += 2) {
+      switch (attrib_pair[0]) {
+        case NP3DAttrib_CommandBufferSize:
+          old_config.commandBufferSize = attrib_pair[1];
+          break;
+        default:
+          return NPERR_GENERIC_ERROR;
+      }
+    }
+  }
+
+  *context = new NPDeviceContext3D;
+  Device3DInitializeContext(&old_config, *context);
+
+  // Flag the context as dynamically created by the browser. TODO(apatrick):
+  // take this out when all contexts are dynamically created.
+  Device3DImpl* impl = static_cast<Device3DImpl*>((*context)->reserved);
+  impl->dynamically_created = true;
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DRegisterCallback(
     NPP id,
     NPDeviceContext3D* context,
     int32 callback_type,
     NPDeviceGenericCallbackPtr callback,
     void* callback_data) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+  switch (callback_type) {
+    case NP3DCallback_Repaint:
+      context->repaintCallback = reinterpret_cast<NPDeviceContext3DRepaintPtr>(
+          callback);
+      break;
+    default:
+      return NPERR_GENERIC_ERROR;
+  }
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DSynchronizeContext(
     NPP id,
     NPDeviceContext3D* context,
     NPDeviceSynchronizationMode mode,
     const int32* input_attrib_list,
     int32* output_attrib_list,
     NPDeviceSynchronizeContextCallbackPtr callback,
     void* callback_data) {
-  return NPERR_GENERIC_ERROR;
+  if (!context)
+    return NPERR_GENERIC_ERROR;
+
+  // Copy input attributes into context.
+  if (input_attrib_list) {
+    for (const int32* attrib_pair = input_attrib_list;
+         *attrib_pair;
+         attrib_pair += 2) {
+      switch (attrib_pair[0]) {
+        case NP3DAttrib_PutOffset:
+          context->putOffset = attrib_pair[1];
+          break;
+        default:
+          return NPERR_GENERIC_ERROR;
+      }
+    }
+  }
+
+  // Use existing flush mechanism for now.
+  if (mode != NPDeviceSynchronizationMode_Cached) {
+    context->waitForProgress = mode == NPDeviceSynchronizationMode_Flush;
+    Device3DFlushContext(id, context, callback, callback_data);
+  }
+
+  // Copy most recent output attributes from context.
+  // To read output attributes after the completion of an asynchronous flush,
+  // invoke SynchronizeContext again with mode
+  // NPDeviceSynchronizationMode_Cached from the callback function.
+  if (output_attrib_list) {
+    for (int32* attrib_pair = output_attrib_list;
+         *attrib_pair;
+         attrib_pair += 2) {
+      switch (attrib_pair[0]) {
+        case NP3DAttrib_CommandBufferSize:
+          attrib_pair[1] = context->commandBufferSize;
+          break;
+        case NP3DAttrib_GetOffset:
+          attrib_pair[1] = context->getOffset;
+          break;
+        case NP3DAttrib_PutOffset:
+          attrib_pair[1] = context->putOffset;
+          break;
+        case NP3DAttrib_Token:
+          attrib_pair[1] = context->token;
+          break;
+        default:
+          return NPERR_GENERIC_ERROR;
+      }
+    }
+  }
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::DeviceAudioQueryCapability(int32 capability,
                                                             int32* value) {
   // TODO(neb,cpu) implement QueryCapability
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::DeviceAudioQueryConfig(
     const NPDeviceContextAudioConfig* request,
@@ skipping 313 matching lines @@
   pdf_output_done_ = false;
 #endif  // defined(OS_LINUX)
 }
 
 WebPluginDelegatePepper::WebPluginDelegatePepper(
     const base::WeakPtr<RenderView>& render_view,
     webkit::npapi::PluginInstance *instance)
     : render_view_(render_view),
       plugin_(NULL),
       instance_(instance),
+      nested_delegate_(NULL),
       current_printer_dpi_(-1),
 #if defined (OS_LINUX)
       num_pages_(0),
       pdf_output_done_(false),
 #endif  // (OS_LINUX)
+#if defined(ENABLE_GPU)
+      command_buffer_(NULL),
+      method_factory3d_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+#endif
       find_identifier_(-1),
       current_choose_file_callback_(NULL),
       current_choose_file_user_data_(NULL) {
   // For now we keep a window struct, although it isn't used.
   memset(&window_, 0, sizeof(window_));
   // All Pepper plugins are windowless and transparent.
   // TODO(sehr): disable resetting these NPPVs by plugins.
   instance->set_windowless(true);
   instance->set_transparent(true);
 }
@@ skipping 17 matching lines @@
   window_.type = NPWindowTypeDrawable;
   instance()->NPP_SetWindow(&window_);
 }
 
 void WebPluginDelegatePepper::PluginDestroyed() {
   delete this;
 }
 
 void WebPluginDelegatePepper::Paint(WebKit::WebCanvas* canvas,
                                     const gfx::Rect& rect) {
-  // Blit from background_context to context.
-  if (!committed_bitmap_.isNull()) {
+  if (nested_delegate_) {
+    // TODO(apatrick): The GPU plugin will render to an offscreen render target.
+    //    Need to copy it to the screen here.
+  } else {
+    // Blit from background_context to context.
+    if (!committed_bitmap_.isNull()) {
 #if defined(OS_MACOSX)
-    DrawSkBitmapToCanvas(committed_bitmap_, canvas, window_rect_,
-                         static_cast<int>(CGBitmapContextGetHeight(canvas)));
+      DrawSkBitmapToCanvas(committed_bitmap_, canvas, window_rect_,
+                           static_cast<int>(CGBitmapContextGetHeight(canvas)));
 #else
-    canvas->drawBitmap(committed_bitmap_,
-                       SkIntToScalar(window_rect_.origin().x()),
-                       SkIntToScalar(window_rect_.origin().y()));
+      canvas->drawBitmap(committed_bitmap_,
+                         SkIntToScalar(window_rect_.origin().x()),
+                         SkIntToScalar(window_rect_.origin().y()));
 #endif
+    }
   }
 }
 
 void WebPluginDelegatePepper::Print(gfx::NativeDrawingContext context) {
   NOTIMPLEMENTED();
 }
 
 void WebPluginDelegatePepper::InstallMissingPlugin() {
   NOTIMPLEMENTED();
 }
@@ skipping 119 matching lines @@
     case NPEventType_Device:
       // NOTIMPLEMENTED();
       break;
   }
   bool rv = instance()->NPP_HandleEvent(&npevent) != 0;
   if (cursor_.get())
     *cursor_info = *cursor_;
   return rv;
 }
 
+#if defined(ENABLE_GPU)
+
+void WebPluginDelegatePepper::ScheduleHandleRepaint(
+    NPP npp, NPDeviceContext3D* context) {
+  command_buffer_->SetNotifyRepaintTask(method_factory3d_.NewRunnableMethod(
+      &WebPluginDelegatePepper::ForwardHandleRepaint,
+      npp,
+      context));
+}
+
+void WebPluginDelegatePepper::ForwardHandleRepaint(
+    NPP npp, NPDeviceContext3D* context) {
+  if (context->repaintCallback)
+    context->repaintCallback(npp, context);
+  ScheduleHandleRepaint(npp, context);
+}
+
+void WebPluginDelegatePepper::Synchronize3DContext(
+    NPDeviceContext3D* context,
+    const gpu::CommandBuffer::State& state) {
+  context->getOffset = state.get_offset;
+  context->putOffset = state.put_offset;
+  context->token = state.token;
+  context->error = static_cast<NPDeviceContext3DError>(state.error);
+}
+
+void WebPluginDelegatePepper::Device3DUpdateState(
+    NPP npp,
+    NPDeviceContext3D* context,
+    NPDeviceFlushContextCallbackPtr callback,
+    void* user_data) {
+  if (command_buffer_) {
+    Synchronize3DContext(context, command_buffer_->GetLastState());
+    if (callback)
+      callback(npp, context, NPERR_NO_ERROR, user_data);
+  }
+}
+
+#endif  // ENABLE_GPU
+
+void WebPluginDelegatePepper::SendNestedDelegateGeometryToBrowser(
+    const gfx::Rect& window_rect,
+    const gfx::Rect& clip_rect) {
+  // Inform the browser about the location of the plugin on the page.
+  // It appears that initially the plugin does not get laid out correctly --
+  // possibly due to lazy creation of the nested delegate.
+  if (!nested_delegate_ ||
+      !nested_delegate_->GetPluginWindowHandle() ||
+      !render_view_) {
+    return;
+  }
+
+  webkit::npapi::WebPluginGeometry geom;
+  geom.window = nested_delegate_->GetPluginWindowHandle();
+  geom.window_rect = window_rect;
+  geom.clip_rect = clip_rect;
+  // Rects_valid must be true for this to work in the Gtk port;
+  // hopefully not having the cutout rects will not cause incorrect
+  // clipping.
+  geom.rects_valid = true;
+  geom.visible = true;
+  render_view_->DidMovePlugin(geom);
+}
+
 bool WebPluginDelegatePepper::CalculatePrintedPageDimensions(
     int page_number,
     NPPPrintExtensions* print_extensions,
     gfx::Size* page_dimensions) {
   int32 width_in_pixels = 0;
   int32 height_in_pixels = 0;
   NPError err = print_extensions->getRasterDimensions(
       instance()->npp(), page_number, &width_in_pixels, &height_in_pixels);
   if (err != NPERR_NO_ERROR)
     return false;
@@ skipping 99 matching lines @@
   CGRect bounds;
   bounds.origin.x = dest_rect.x();
   bounds.origin.y = canvas_height - dest_rect.y() - dest_rect.height();
   bounds.size.width = dest_rect.width();
   bounds.size.height = dest_rect.height();
 
   CGContextDrawImage(canvas, bounds, image);
   CGContextRestoreGState(canvas);
 }
 #endif  // defined(OS_MACOSX)