src/content/renderer/npapi/webplugin_delegate_proxy.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/npapi/webplugin_delegate_proxy.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/auto_reset.h"
  10 #include "base/basictypes.h"
  11 #include "base/command_line.h"
  12 #include "base/file_util.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/process/process.h"
  17 #include "base/strings/string_split.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "base/version.h"
  21 #include "content/child/child_process.h"
  22 #include "content/child/npapi/npobject_proxy.h"
  23 #include "content/child/npapi/npobject_stub.h"
  24 #include "content/child/npapi/npobject_util.h"
  25 #include "content/child/npapi/webplugin_resource_client.h"
  26 #include "content/child/plugin_messages.h"
  27 #include "content/common/content_constants_internal.h"
  28 #include "content/common/cursors/webcursor.h"
  29 #include "content/common/frame_messages.h"
  30 #include "content/common/view_messages.h"
  31 #include "content/public/renderer/content_renderer_client.h"
  32 #include "content/renderer/npapi/plugin_channel_host.h"
  33 #include "content/renderer/npapi/webplugin_impl.h"
  34 #include "content/renderer/render_thread_impl.h"
  35 #include "content/renderer/render_view_impl.h"
  36 #include "content/renderer/sad_plugin.h"
  37 #include "ipc/ipc_channel_handle.h"
  38 #include "net/base/mime_util.h"
  39 #include "skia/ext/platform_canvas.h"
  40 #include "third_party/WebKit/public/platform/WebDragData.h"
  41 #include "third_party/WebKit/public/platform/WebString.h"
  42 #include "third_party/WebKit/public/web/WebBindings.h"
  43 #include "third_party/WebKit/public/web/WebDocument.h"
  44 #include "third_party/WebKit/public/web/WebFrame.h"
  45 #include "third_party/WebKit/public/web/WebView.h"
  46 #include "ui/gfx/blit.h"
  47 #include "ui/gfx/canvas.h"
  48 #include "ui/gfx/native_widget_types.h"
  49 #include "ui/gfx/size.h"
  50 #include "ui/gfx/skia_util.h"
  51
  52 #if defined(OS_POSIX)
  53 #include "ipc/ipc_channel_posix.h"
  54 #endif
  55
  56 #if defined(OS_MACOSX)
  57 #include "base/mac/mac_util.h"
  58 #endif
  59
  60 #if defined(OS_WIN)
  61 #include "content/public/common/sandbox_init.h"
  62 #endif
  63
  64 using blink::WebBindings;
  65 using blink::WebCursorInfo;
  66 using blink::WebDragData;
  67 using blink::WebInputEvent;
  68 using blink::WebString;
  69 using blink::WebView;
  70
  71 namespace content {
  72
  73 namespace {
  74
  75 class ScopedLogLevel {
  76  public:
  77   explicit ScopedLogLevel(int level);
  78   ~ScopedLogLevel();
  79
  80  private:
  81   int old_level_;
  82
  83   DISALLOW_COPY_AND_ASSIGN(ScopedLogLevel);
  84 };
  85
  86 ScopedLogLevel::ScopedLogLevel(int level)
  87     : old_level_(logging::GetMinLogLevel()) {
  88   logging::SetMinLogLevel(level);
  89 }
  90
  91 ScopedLogLevel::~ScopedLogLevel() {
  92   logging::SetMinLogLevel(old_level_);
  93 }
  94
  95 // Proxy for WebPluginResourceClient.  The object owns itself after creation,
  96 // deleting itself after its callback has been called.
  97 class ResourceClientProxy : public WebPluginResourceClient {
  98  public:
  99   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
 100     : channel_(channel), instance_id_(instance_id), resource_id_(0),
 101       multibyte_response_expected_(false) {
 102   }
 103
 104   virtual ~ResourceClientProxy() {
 105   }
 106
 107   void Initialize(unsigned long resource_id, const GURL& url, int notify_id) {
 108     resource_id_ = resource_id;
 109     channel_->Send(new PluginMsg_HandleURLRequestReply(
 110         instance_id_, resource_id, url, notify_id));
 111   }
 112
 113   void InitializeForSeekableStream(unsigned long resource_id,
 114                                    int range_request_id) {
 115     resource_id_ = resource_id;
 116     multibyte_response_expected_ = true;
 117     channel_->Send(new PluginMsg_HTTPRangeRequestReply(
 118         instance_id_, resource_id, range_request_id));
 119   }
 120
 121   // PluginResourceClient implementation:
 122   virtual void WillSendRequest(const GURL& url, int http_status_code) OVERRIDE {
 123     DCHECK(channel_.get() != NULL);
 124     channel_->Send(new PluginMsg_WillSendRequest(
 125         instance_id_, resource_id_, url, http_status_code));
 126   }
 127
 128   virtual void DidReceiveResponse(const std::string& mime_type,
 129                                   const std::string& headers,
 130                                   uint32 expected_length,
 131                                   uint32 last_modified,
 132                                   bool request_is_seekable) OVERRIDE {
 133     DCHECK(channel_.get() != NULL);
 134     PluginMsg_DidReceiveResponseParams params;
 135     params.id = resource_id_;
 136     params.mime_type = mime_type;
 137     params.headers = headers;
 138     params.expected_length = expected_length;
 139     params.last_modified = last_modified;
 140     params.request_is_seekable = request_is_seekable;
 141     // Grab a reference on the underlying channel so it does not get
 142     // deleted from under us.
 143     scoped_refptr<PluginChannelHost> channel_ref(channel_);
 144     channel_->Send(new PluginMsg_DidReceiveResponse(instance_id_, params));
 145   }
 146
 147   virtual void DidReceiveData(const char* buffer,
 148                               int length,
 149                               int data_offset) OVERRIDE {
 150     DCHECK(channel_.get() != NULL);
 151     DCHECK_GT(length, 0);
 152     std::vector<char> data;
 153     data.resize(static_cast<size_t>(length));
 154     memcpy(&data.front(), buffer, length);
 155     // Grab a reference on the underlying channel so it does not get
 156     // deleted from under us.
 157     scoped_refptr<PluginChannelHost> channel_ref(channel_);
 158     channel_->Send(new PluginMsg_DidReceiveData(instance_id_, resource_id_,
 159                                                 data, data_offset));
 160   }
 161
 162   virtual void DidFinishLoading(unsigned long resource_id) OVERRIDE {
 163     DCHECK(channel_.get() != NULL);
 164     DCHECK_EQ(resource_id, resource_id_);
 165     channel_->Send(new PluginMsg_DidFinishLoading(instance_id_, resource_id_));
 166     channel_ = NULL;
 167     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 168   }
 169
 170   virtual void DidFail(unsigned long resource_id) OVERRIDE {
 171     DCHECK(channel_.get() != NULL);
 172     DCHECK_EQ(resource_id, resource_id_);
 173     channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_));
 174     channel_ = NULL;
 175     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 176   }
 177
 178   virtual bool IsMultiByteResponseExpected() OVERRIDE {
 179     return multibyte_response_expected_;
 180   }
 181
 182   virtual int ResourceId() OVERRIDE {
 183     return resource_id_;
 184   }
 185
 186  private:
 187   scoped_refptr<PluginChannelHost> channel_;
 188   int instance_id_;
 189   unsigned long resource_id_;
 190   // Set to true if the response expected is a multibyte response.
 191   // For e.g. response for a HTTP byte range request.
 192   bool multibyte_response_expected_;
 193 };
 194
 195 }  // namespace
 196
 197 WebPluginDelegateProxy::WebPluginDelegateProxy(
 198     WebPluginImpl* plugin,
 199     const std::string& mime_type,
 200     const base::WeakPtr<RenderViewImpl>& render_view,
 201     RenderFrameImpl* render_frame)
 202     : render_view_(render_view),
 203       render_frame_(render_frame),
 204       plugin_(plugin),
 205       uses_shared_bitmaps_(false),
 206 #if defined(OS_MACOSX)
 207       uses_compositor_(false),
 208 #elif defined(OS_WIN)
 209       dummy_activation_window_(NULL),
 210 #endif
 211       window_(gfx::kNullPluginWindow),
 212       mime_type_(mime_type),
 213       instance_id_(MSG_ROUTING_NONE),
 214       npobject_(NULL),
 215       npp_(new NPP_t),
 216       sad_plugin_(NULL),
 217       invalidate_pending_(false),
 218       transparent_(false),
 219       front_buffer_index_(0),
 220       page_url_(render_view_->webview()->mainFrame()->document().url()) {
 221 }
 222
 223 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
 224   if (npobject_)
 225     WebBindings::releaseObject(npobject_);
 226 }
 227
 228 WebPluginDelegateProxy::SharedBitmap::SharedBitmap() {}
 229
 230 WebPluginDelegateProxy::SharedBitmap::~SharedBitmap() {}
 231
 232 void WebPluginDelegateProxy::PluginDestroyed() {
 233 #if defined(OS_MACOSX) || defined(OS_WIN)
 234   // Ensure that the renderer doesn't think the plugin still has focus.
 235   if (render_view_)
 236     render_view_->PluginFocusChanged(false, instance_id_);
 237 #endif
 238
 239 #if defined(OS_WIN)
 240   if (dummy_activation_window_ && render_view_) {
 241     render_view_->Send(new ViewHostMsg_WindowlessPluginDummyWindowDestroyed(
 242         render_view_->routing_id(), dummy_activation_window_));
 243   }
 244   dummy_activation_window_ = NULL;
 245 #endif
 246
 247   if (window_)
 248     WillDestroyWindow();
 249
 250   if (render_view_.get())
 251     render_view_->UnregisterPluginDelegate(this);
 252
 253   if (channel_host_.get()) {
 254     Send(new PluginMsg_DestroyInstance(instance_id_));
 255
 256     // Must remove the route after sending the destroy message, rather than
 257     // before, since RemoveRoute can lead to all the outstanding NPObjects
 258     // being told the channel went away if this was the last instance.
 259     channel_host_->RemoveRoute(instance_id_);
 260
 261     // Remove the mapping between our instance-Id and NPP identifiers, used by
 262     // the channel to track object ownership, before releasing it.
 263     channel_host_->RemoveMappingForNPObjectOwner(instance_id_);
 264
 265     // Release the channel host now. If we are is the last reference to the
 266     // channel, this avoids a race where this renderer asks a new connection to
 267     // the same plugin between now and the time 'this' is actually deleted.
 268     // Destroying the channel host is what releases the channel name -> FD
 269     // association on POSIX, and if we ask for a new connection before it is
 270     // released, the plugin will give us a new FD, and we'll assert when trying
 271     // to associate it with the channel name.
 272     channel_host_ = NULL;
 273   }
 274
 275   plugin_ = NULL;
 276
 277   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 278 }
 279
 280 bool WebPluginDelegateProxy::Initialize(
 281     const GURL& url,
 282     const std::vector<std::string>& arg_names,
 283     const std::vector<std::string>& arg_values,
 284     bool load_manually) {
 285   // TODO(shess): Attempt to work around http://crbug.com/97285 and
 286   // http://crbug.com/141055 by retrying the connection.  Reports seem
 287   // to indicate that the plugin hasn't crashed, and that the problem
 288   // is not 100% persistent.
 289   const size_t kAttempts = 2;
 290
 291   bool result = false;
 292   scoped_refptr<PluginChannelHost> channel_host;
 293   int instance_id = 0;
 294
 295   for (size_t attempt = 0; !result && attempt < kAttempts; attempt++) {
 296 #if defined(OS_MACOSX)
 297     // TODO(shess): Debugging for http://crbug.com/97285 .  See comment
 298     // in plugin_channel_host.cc.
 299     scoped_ptr<base::AutoReset<bool> > track_nested_removes(
 300         new base::AutoReset<bool>(PluginChannelHost::GetRemoveTrackingFlag(),
 301                                   true));
 302 #endif
 303
 304     IPC::ChannelHandle channel_handle;
 305     if (!RenderThreadImpl::current()->Send(new FrameHostMsg_OpenChannelToPlugin(
 306             render_frame_->GetRoutingID(), url, page_url_, mime_type_,
 307             &channel_handle, &info_))) {
 308       continue;
 309     }
 310
 311     if (channel_handle.name.empty()) {
 312       // We got an invalid handle.  Either the plugin couldn't be found (which
 313       // shouldn't happen, since if we got here the plugin should exist) or the
 314       // plugin crashed on initialization.
 315       if (!info_.path.empty()) {
 316         render_view_->main_render_frame()->PluginCrashed(
 317             info_.path, base::kNullProcessId);
 318         LOG(ERROR) << "Plug-in crashed on start";
 319
 320         // Return true so that the plugin widget is created and we can paint the
 321         // crashed plugin there.
 322         return true;
 323       }
 324       LOG(ERROR) << "Plug-in couldn't be found";
 325       return false;
 326     }
 327
 328     channel_host =
 329         PluginChannelHost::GetPluginChannelHost(
 330             channel_handle, ChildProcess::current()->io_message_loop_proxy());
 331     if (!channel_host.get()) {
 332       LOG(ERROR) << "Couldn't get PluginChannelHost";
 333       continue;
 334     }
 335 #if defined(OS_MACOSX)
 336     track_nested_removes.reset();
 337 #endif
 338
 339     {
 340       // TODO(bauerb): Debugging for http://crbug.com/141055.
 341       ScopedLogLevel log_level(-2);  // Equivalent to --v=2
 342       result = channel_host->Send(new PluginMsg_CreateInstance(
 343           mime_type_, &instance_id));
 344       if (!result) {
 345         LOG(ERROR) << "Couldn't send PluginMsg_CreateInstance";
 346         continue;
 347       }
 348     }
 349   }
 350
 351   // Failed too often, give up.
 352   if (!result)
 353     return false;
 354
 355   channel_host_ = channel_host;
 356   instance_id_ = instance_id;
 357
 358   channel_host_->AddRoute(instance_id_, this, NULL);
 359
 360   // Inform the channel of the mapping between our instance-Id and dummy NPP
 361   // identifier, for use in object ownership tracking.
 362   channel_host_->AddMappingForNPObjectOwner(instance_id_, GetPluginNPP());
 363
 364   // Now tell the PluginInstance in the plugin process to initialize.
 365   PluginMsg_Init_Params params;
 366   params.url = url;
 367   params.page_url = page_url_;
 368   params.arg_names = arg_names;
 369   params.arg_values = arg_values;
 370   params.host_render_view_routing_id = render_view_->routing_id();
 371   params.load_manually = load_manually;
 372
 373   result = false;
 374   Send(new PluginMsg_Init(instance_id_, params, &transparent_, &result));
 375
 376   if (!result)
 377     LOG(WARNING) << "PluginMsg_Init returned false";
 378
 379   render_view_->RegisterPluginDelegate(this);
 380
 381   return result;
 382 }
 383
 384 bool WebPluginDelegateProxy::Send(IPC::Message* msg) {
 385   if (!channel_host_.get()) {
 386     DLOG(WARNING) << "dropping message because channel host is null";
 387     delete msg;
 388     return false;
 389   }
 390
 391   return channel_host_->Send(msg);
 392 }
 393
 394 void WebPluginDelegateProxy::SendJavaScriptStream(const GURL& url,
 395                                                   const std::string& result,
 396                                                   bool success,
 397                                                   int notify_id) {
 398   Send(new PluginMsg_SendJavaScriptStream(
 399       instance_id_, url, result, success, notify_id));
 400 }
 401
 402 void WebPluginDelegateProxy::DidReceiveManualResponse(
 403     const GURL& url, const std::string& mime_type,
 404     const std::string& headers, uint32 expected_length,
 405     uint32 last_modified) {
 406   PluginMsg_DidReceiveResponseParams params;
 407   params.id = 0;
 408   params.mime_type = mime_type;
 409   params.headers = headers;
 410   params.expected_length = expected_length;
 411   params.last_modified = last_modified;
 412   Send(new PluginMsg_DidReceiveManualResponse(instance_id_, url, params));
 413 }
 414
 415 void WebPluginDelegateProxy::DidReceiveManualData(const char* buffer,
 416                                                   int length) {
 417   DCHECK_GT(length, 0);
 418   std::vector<char> data;
 419   data.resize(static_cast<size_t>(length));
 420   memcpy(&data.front(), buffer, length);
 421   Send(new PluginMsg_DidReceiveManualData(instance_id_, data));
 422 }
 423
 424 void WebPluginDelegateProxy::DidFinishManualLoading() {
 425   Send(new PluginMsg_DidFinishManualLoading(instance_id_));
 426 }
 427
 428 void WebPluginDelegateProxy::DidManualLoadFail() {
 429   Send(new PluginMsg_DidManualLoadFail(instance_id_));
 430 }
 431
 432 bool WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) {
 433   GetContentClient()->SetActiveURL(page_url_);
 434
 435   bool handled = true;
 436   IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg)
 437     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow)
 438     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelResource, OnCancelResource)
 439     IPC_MESSAGE_HANDLER(PluginHostMsg_InvalidateRect, OnInvalidateRect)
 440     IPC_MESSAGE_HANDLER(PluginHostMsg_GetWindowScriptNPObject,
 441                         OnGetWindowScriptNPObject)
 442     IPC_MESSAGE_HANDLER(PluginHostMsg_GetPluginElement, OnGetPluginElement)
 443     IPC_MESSAGE_HANDLER(PluginHostMsg_ResolveProxy, OnResolveProxy)
 444     IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie)
 445     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies)
 446     IPC_MESSAGE_HANDLER(PluginHostMsg_URLRequest, OnHandleURLRequest)
 447     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad)
 448     IPC_MESSAGE_HANDLER(PluginHostMsg_InitiateHTTPRangeRequest,
 449                         OnInitiateHTTPRangeRequest)
 450     IPC_MESSAGE_HANDLER(PluginHostMsg_DidStartLoading, OnDidStartLoading)
 451     IPC_MESSAGE_HANDLER(PluginHostMsg_DidStopLoading, OnDidStopLoading)
 452     IPC_MESSAGE_HANDLER(PluginHostMsg_DeferResourceLoading,
 453                         OnDeferResourceLoading)
 454     IPC_MESSAGE_HANDLER(PluginHostMsg_URLRedirectResponse,
 455                         OnURLRedirectResponse)
 456     IPC_MESSAGE_HANDLER(PluginHostMsg_CheckIfRunInsecureContent,
 457                         OnCheckIfRunInsecureContent)
 458 #if defined(OS_WIN)
 459     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessData, OnSetWindowlessData)
 460     IPC_MESSAGE_HANDLER(PluginHostMsg_NotifyIMEStatus, OnNotifyIMEStatus)
 461 #endif
 462 #if defined(OS_MACOSX)
 463     IPC_MESSAGE_HANDLER(PluginHostMsg_FocusChanged,
 464                         OnFocusChanged);
 465     IPC_MESSAGE_HANDLER(PluginHostMsg_StartIme,
 466                         OnStartIme);
 467     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginEnabledRendering,
 468                         OnAcceleratedPluginEnabledRendering)
 469     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginAllocatedIOSurface,
 470                         OnAcceleratedPluginAllocatedIOSurface)
 471     IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginSwappedIOSurface,
 472                         OnAcceleratedPluginSwappedIOSurface)
 473 #endif
 474     IPC_MESSAGE_UNHANDLED(handled = false)
 475   IPC_END_MESSAGE_MAP()
 476   DCHECK(handled);
 477   return handled;
 478 }
 479
 480 void WebPluginDelegateProxy::OnChannelError() {
 481   if (plugin_) {
 482     if (window_) {
 483       // The actual WebPluginDelegate never got a chance to tell the WebPlugin
 484       // its window was going away. Do it on its behalf.
 485       WillDestroyWindow();
 486     }
 487     plugin_->Invalidate();
 488   }
 489   if (!channel_host_->expecting_shutdown()) {
 490     render_view_->main_render_frame()->PluginCrashed(
 491         info_.path, channel_host_->peer_pid());
 492   }
 493
 494 #if defined(OS_MACOSX) || defined(OS_WIN)
 495   // Ensure that the renderer doesn't think the plugin still has focus.
 496   if (render_view_)
 497     render_view_->PluginFocusChanged(false, instance_id_);
 498 #endif
 499 }
 500
 501 static void CopyTransportDIBHandleForMessage(
 502     const TransportDIB::Handle& handle_in,
 503     TransportDIB::Handle* handle_out,
 504     base::ProcessId peer_pid) {
 505 #if defined(OS_MACOSX)
 506   // On Mac, TransportDIB::Handle is typedef'ed to FileDescriptor, and
 507   // FileDescriptor message fields needs to remain valid until the message is
 508   // sent or else the sendmsg() call will fail.
 509   if ((handle_out->fd = HANDLE_EINTR(dup(handle_in.fd))) < 0) {
 510     PLOG(ERROR) << "dup()";
 511     return;
 512   }
 513   handle_out->auto_close = true;
 514 #elif defined(OS_WIN)
 515   // On Windows we need to duplicate the handle for the plugin process.
 516   *handle_out = NULL;
 517   BrokerDuplicateHandle(handle_in, peer_pid, handle_out,
 518                         FILE_MAP_READ | FILE_MAP_WRITE, 0);
 519   DCHECK(*handle_out != NULL);
 520 #else
 521   // Don't need to do anything special for other platforms.
 522   *handle_out = handle_in;
 523 #endif
 524 }
 525
 526 void WebPluginDelegateProxy::SendUpdateGeometry(
 527     bool bitmaps_changed) {
 528   PluginMsg_UpdateGeometry_Param param;
 529   param.window_rect = plugin_rect_;
 530   param.clip_rect = clip_rect_;
 531   param.windowless_buffer0 = TransportDIB::DefaultHandleValue();
 532   param.windowless_buffer1 = TransportDIB::DefaultHandleValue();
 533   param.windowless_buffer_index = back_buffer_index();
 534
 535 #if defined(OS_POSIX)
 536   // If we're using POSIX mmap'd TransportDIBs, sending the handle across
 537   // IPC establishes a new mapping rather than just sending a window ID,
 538   // so only do so if we've actually changed the shared memory bitmaps.
 539   if (bitmaps_changed)
 540 #endif
 541   {
 542     if (transport_stores_[0].dib)
 543       CopyTransportDIBHandleForMessage(transport_stores_[0].dib->handle(),
 544                                        &param.windowless_buffer0,
 545                                        channel_host_->peer_pid());
 546
 547     if (transport_stores_[1].dib)
 548       CopyTransportDIBHandleForMessage(transport_stores_[1].dib->handle(),
 549                                        &param.windowless_buffer1,
 550                                        channel_host_->peer_pid());
 551   }
 552
 553   IPC::Message* msg;
 554 #if defined(OS_WIN)
 555   if (UseSynchronousGeometryUpdates()) {
 556     msg = new PluginMsg_UpdateGeometrySync(instance_id_, param);
 557   } else  // NOLINT
 558 #endif
 559   {
 560     msg = new PluginMsg_UpdateGeometry(instance_id_, param);
 561     msg->set_unblock(true);
 562   }
 563
 564   Send(msg);
 565 }
 566
 567 void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect,
 568                                             const gfx::Rect& clip_rect) {
 569   // window_rect becomes either a window in native windowing system
 570   // coords, or a backing buffer.  In either case things will go bad
 571   // if the rectangle is very large.
 572   if (window_rect.width() < 0  || window_rect.width() > kMaxPluginSideLength ||
 573       window_rect.height() < 0 || window_rect.height() > kMaxPluginSideLength ||
 574       // We know this won't overflow due to above checks.
 575       static_cast<uint32>(window_rect.width()) *
 576           static_cast<uint32>(window_rect.height()) > kMaxPluginSize) {
 577     return;
 578   }
 579
 580   plugin_rect_ = window_rect;
 581   clip_rect_ = clip_rect;
 582
 583   bool bitmaps_changed = false;
 584
 585   if (uses_shared_bitmaps_) {
 586     if (!front_buffer_canvas() ||
 587         (window_rect.width() != front_buffer_canvas()->getDevice()->width() ||
 588          window_rect.height() != front_buffer_canvas()->getDevice()->height()))
 589     {
 590       bitmaps_changed = true;
 591
 592       // Create a shared memory section that the plugin paints into
 593       // asynchronously.
 594       ResetWindowlessBitmaps();
 595       if (!window_rect.IsEmpty()) {
 596         if (!CreateSharedBitmap(&transport_stores_[0].dib,
 597                                 &transport_stores_[0].canvas) ||
 598             !CreateSharedBitmap(&transport_stores_[1].dib,
 599                                 &transport_stores_[1].canvas)) {
 600           DCHECK(false);
 601           ResetWindowlessBitmaps();
 602           return;
 603         }
 604       }
 605     }
 606   }
 607
 608   SendUpdateGeometry(bitmaps_changed);
 609 }
 610
 611 void WebPluginDelegateProxy::ResetWindowlessBitmaps() {
 612   transport_stores_[0].dib.reset();
 613   transport_stores_[1].dib.reset();
 614
 615   transport_stores_[0].canvas.reset();
 616   transport_stores_[1].canvas.reset();
 617   transport_store_painted_ = gfx::Rect();
 618   front_buffer_diff_ = gfx::Rect();
 619 }
 620
 621 static size_t BitmapSizeForPluginRect(const gfx::Rect& plugin_rect) {
 622   const size_t stride =
 623       skia::PlatformCanvasStrideForWidth(plugin_rect.width());
 624   return stride * plugin_rect.height();
 625 }
 626
 627 #if !defined(OS_WIN)
 628 bool WebPluginDelegateProxy::CreateLocalBitmap(
 629     std::vector<uint8>* memory,
 630     scoped_ptr<skia::PlatformCanvas>* canvas) {
 631   const size_t size = BitmapSizeForPluginRect(plugin_rect_);
 632   memory->resize(size);
 633   if (memory->size() != size)
 634     return false;
 635   canvas->reset(skia::CreatePlatformCanvas(
 636       plugin_rect_.width(), plugin_rect_.height(), true, &((*memory)[0]),
 637       skia::CRASH_ON_FAILURE));
 638   return true;
 639 }
 640 #endif
 641
 642 bool WebPluginDelegateProxy::CreateSharedBitmap(
 643     scoped_ptr<TransportDIB>* memory,
 644     scoped_ptr<skia::PlatformCanvas>* canvas) {
 645   const size_t size = BitmapSizeForPluginRect(plugin_rect_);
 646 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 647   memory->reset(TransportDIB::Create(size, 0));
 648   if (!memory->get())
 649     return false;
 650 #endif
 651 #if defined(OS_POSIX) && !defined(OS_ANDROID)
 652   TransportDIB::Handle handle;
 653   IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(size, false, &handle);
 654   if (!RenderThreadImpl::current()->Send(msg))
 655     return false;
 656   if (handle.fd < 0)
 657     return false;
 658   memory->reset(TransportDIB::Map(handle));
 659 #else
 660   static uint32 sequence_number = 0;
 661   memory->reset(TransportDIB::Create(size, sequence_number++));
 662 #endif
 663   canvas->reset((*memory)->GetPlatformCanvas(plugin_rect_.width(),
 664                                              plugin_rect_.height()));
 665   return !!canvas->get();
 666 }
 667
 668 void WebPluginDelegateProxy::Paint(SkCanvas* canvas,
 669                                    const gfx::Rect& damaged_rect) {
 670   // Limit the damaged rectangle to whatever is contained inside the plugin
 671   // rectangle, as that's the rectangle that we'll actually draw.
 672   gfx::Rect rect = gfx::IntersectRects(damaged_rect, plugin_rect_);
 673
 674   // If the plugin is no longer connected (channel crashed) draw a crashed
 675   // plugin bitmap
 676   if (!channel_host_.get() || !channel_host_->channel_valid()) {
 677     // Lazily load the sad plugin image.
 678     if (!sad_plugin_)
 679       sad_plugin_ = GetContentClient()->renderer()->GetSadPluginBitmap();
 680     if (sad_plugin_)
 681       PaintSadPlugin(canvas, plugin_rect_, *sad_plugin_);
 682     return;
 683   }
 684
 685   if (!uses_shared_bitmaps_)
 686     return;
 687
 688   // We got a paint before the plugin's coordinates, so there's no buffer to
 689   // copy from.
 690   if (!front_buffer_canvas())
 691     return;
 692
 693   gfx::Rect offset_rect = rect;
 694   offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
 695
 696   // transport_store_painted_ is really a bounding box, so in principle this
 697   // check could falsely indicate that we don't need to paint offset_rect, but
 698   // in practice it works fine.
 699   if (!transport_store_painted_.Contains(offset_rect)) {
 700     Send(new PluginMsg_Paint(instance_id_, offset_rect));
 701     // Since the plugin is not blocked on the renderer in this context, there is
 702     // a chance that it will begin repainting the back-buffer before we complete
 703     // capturing the data. Buffer flipping would increase that risk because
 704     // geometry update is asynchronous, so we don't want to use buffer flipping
 705     // here.
 706     UpdateFrontBuffer(offset_rect, false);
 707   }
 708
 709   const SkBitmap& bitmap =
 710       front_buffer_canvas()->getDevice()->accessBitmap(false);
 711   SkPaint paint;
 712   paint.setXfermodeMode(
 713       transparent_ ? SkXfermode::kSrcATop_Mode : SkXfermode::kSrc_Mode);
 714   SkIRect src_rect = gfx::RectToSkIRect(offset_rect);
 715   canvas->drawBitmapRect(bitmap,
 716                          &src_rect,
 717                          gfx::RectToSkRect(rect),
 718                          &paint);
 719
 720   if (invalidate_pending_) {
 721     // Only send the PaintAck message if this paint is in response to an
 722     // invalidate from the plugin, since this message acts as an access token
 723     // to ensure only one process is using the transport dib at a time.
 724     invalidate_pending_ = false;
 725     Send(new PluginMsg_DidPaint(instance_id_));
 726   }
 727 }
 728
 729 NPObject* WebPluginDelegateProxy::GetPluginScriptableObject() {
 730   if (npobject_)
 731     return WebBindings::retainObject(npobject_);
 732
 733   int route_id = MSG_ROUTING_NONE;
 734   Send(new PluginMsg_GetPluginScriptableObject(instance_id_, &route_id));
 735   if (route_id == MSG_ROUTING_NONE)
 736     return NULL;
 737
 738   npobject_ = NPObjectProxy::Create(
 739       channel_host_.get(), route_id, 0, page_url_, GetPluginNPP());
 740
 741   return WebBindings::retainObject(npobject_);
 742 }
 743
 744 NPP WebPluginDelegateProxy::GetPluginNPP() {
 745   // Return a dummy NPP for WebKit to use to identify this plugin.
 746   return npp_.get();
 747 }
 748
 749 bool WebPluginDelegateProxy::GetFormValue(base::string16* value) {
 750   bool success = false;
 751   Send(new PluginMsg_GetFormValue(instance_id_, value, &success));
 752   return success;
 753 }
 754
 755 void WebPluginDelegateProxy::DidFinishLoadWithReason(
 756     const GURL& url, NPReason reason, int notify_id) {
 757   Send(new PluginMsg_DidFinishLoadWithReason(
 758       instance_id_, url, reason, notify_id));
 759 }
 760
 761 void WebPluginDelegateProxy::SetFocus(bool focused) {
 762   Send(new PluginMsg_SetFocus(instance_id_, focused));
 763 #if defined(OS_WIN)
 764   if (render_view_)
 765     render_view_->PluginFocusChanged(focused, instance_id_);
 766 #endif
 767 }
 768
 769 bool WebPluginDelegateProxy::HandleInputEvent(
 770     const WebInputEvent& event,
 771     WebCursor::CursorInfo* cursor_info) {
 772   bool handled;
 773   WebCursor cursor;
 774   // A windowless plugin can enter a modal loop in the context of a
 775   // NPP_HandleEvent call, in which case we need to pump messages to
 776   // the plugin. We pass of the corresponding event handle to the
 777   // plugin process, which is set if the plugin does enter a modal loop.
 778   IPC::SyncMessage* message = new PluginMsg_HandleInputEvent(
 779       instance_id_, &event, &handled, &cursor);
 780   message->set_pump_messages_event(modal_loop_pump_messages_event_.get());
 781   Send(message);
 782   return handled;
 783 }
 784
 785 int WebPluginDelegateProxy::GetProcessId() {
 786   return channel_host_->peer_pid();
 787 }
 788
 789 void WebPluginDelegateProxy::SetContentAreaFocus(bool has_focus) {
 790   IPC::Message* msg = new PluginMsg_SetContentAreaFocus(instance_id_,
 791                                                         has_focus);
 792   // Make sure focus events are delivered in the right order relative to
 793   // sync messages they might interact with (Paint, HandleEvent, etc.).
 794   msg->set_unblock(true);
 795   Send(msg);
 796 }
 797
 798 #if defined(OS_WIN)
 799 void WebPluginDelegateProxy::ImeCompositionUpdated(
 800     const base::string16& text,
 801     const std::vector<int>& clauses,
 802     const std::vector<int>& target,
 803     int cursor_position,
 804     int plugin_id) {
 805   // Dispatch the raw IME data if this plug-in is the focused one.
 806   if (instance_id_ != plugin_id)
 807     return;
 808
 809   IPC::Message* msg = new PluginMsg_ImeCompositionUpdated(instance_id_,
 810       text, clauses, target, cursor_position);
 811   msg->set_unblock(true);
 812   Send(msg);
 813 }
 814
 815 void WebPluginDelegateProxy::ImeCompositionCompleted(const base::string16& text,
 816                                                      int plugin_id) {
 817   // Dispatch the IME text if this plug-in is the focused one.
 818   if (instance_id_ != plugin_id)
 819     return;
 820
 821   IPC::Message* msg = new PluginMsg_ImeCompositionCompleted(instance_id_, text);
 822   msg->set_unblock(true);
 823   Send(msg);
 824 }
 825 #endif
 826
 827 #if defined(OS_MACOSX)
 828 void WebPluginDelegateProxy::SetWindowFocus(bool window_has_focus) {
 829   IPC::Message* msg = new PluginMsg_SetWindowFocus(instance_id_,
 830                                                    window_has_focus);
 831   // Make sure focus events are delivered in the right order relative to
 832   // sync messages they might interact with (Paint, HandleEvent, etc.).
 833   msg->set_unblock(true);
 834   Send(msg);
 835 }
 836
 837 void WebPluginDelegateProxy::SetContainerVisibility(bool is_visible) {
 838   IPC::Message* msg;
 839   if (is_visible) {
 840     gfx::Rect window_frame = render_view_->rootWindowRect();
 841     gfx::Rect view_frame = render_view_->windowRect();
 842     blink::WebView* webview = render_view_->webview();
 843     msg = new PluginMsg_ContainerShown(instance_id_, window_frame, view_frame,
 844                                        webview && webview->isActive());
 845   } else {
 846     msg = new PluginMsg_ContainerHidden(instance_id_);
 847   }
 848   // Make sure visibility events are delivered in the right order relative to
 849   // sync messages they might interact with (Paint, HandleEvent, etc.).
 850   msg->set_unblock(true);
 851   Send(msg);
 852 }
 853
 854 void WebPluginDelegateProxy::WindowFrameChanged(gfx::Rect window_frame,
 855                                                 gfx::Rect view_frame) {
 856   IPC::Message* msg = new PluginMsg_WindowFrameChanged(instance_id_,
 857                                                        window_frame,
 858                                                        view_frame);
 859   // Make sure frame events are delivered in the right order relative to
 860   // sync messages they might interact with (e.g., HandleEvent).
 861   msg->set_unblock(true);
 862   Send(msg);
 863 }
 864 void WebPluginDelegateProxy::ImeCompositionCompleted(const base::string16& text,
 865                                                      int plugin_id) {
 866   // If the message isn't intended for this plugin, there's nothing to do.
 867   if (instance_id_ != plugin_id)
 868     return;
 869
 870   IPC::Message* msg = new PluginMsg_ImeCompositionCompleted(instance_id_,
 871                                                             text);
 872   // Order relative to other key events is important.
 873   msg->set_unblock(true);
 874   Send(msg);
 875 }
 876 #endif  // OS_MACOSX
 877
 878 void WebPluginDelegateProxy::OnSetWindow(gfx::PluginWindowHandle window) {
 879 #if defined(OS_MACOSX)
 880   uses_shared_bitmaps_ = !window && !uses_compositor_;
 881 #else
 882   uses_shared_bitmaps_ = !window;
 883 #endif
 884   window_ = window;
 885   if (plugin_)
 886     plugin_->SetWindow(window);
 887 }
 888
 889 void WebPluginDelegateProxy::WillDestroyWindow() {
 890   DCHECK(window_);
 891   plugin_->WillDestroyWindow(window_);
 892   window_ = gfx::kNullPluginWindow;
 893 }
 894
 895 #if defined(OS_WIN)
 896 void WebPluginDelegateProxy::OnSetWindowlessData(
 897       HANDLE modal_loop_pump_messages_event,
 898       gfx::NativeViewId dummy_activation_window) {
 899   DCHECK(modal_loop_pump_messages_event_ == NULL);
 900   DCHECK(dummy_activation_window_ == NULL);
 901
 902   dummy_activation_window_ = dummy_activation_window;
 903   render_view_->Send(new ViewHostMsg_WindowlessPluginDummyWindowCreated(
 904       render_view_->routing_id(), dummy_activation_window_));
 905
 906   // Bug 25583: this can be null because some "virus scanners" block the
 907   // DuplicateHandle call in the plugin process.
 908   if (!modal_loop_pump_messages_event)
 909     return;
 910
 911   modal_loop_pump_messages_event_.reset(
 912       new base::WaitableEvent(modal_loop_pump_messages_event));
 913 }
 914
 915 void WebPluginDelegateProxy::OnNotifyIMEStatus(int input_type,
 916                                                const gfx::Rect& caret_rect) {
 917   if (!render_view_)
 918     return;
 919
 920   render_view_->Send(new ViewHostMsg_TextInputTypeChanged(
 921       render_view_->routing_id(),
 922       static_cast<ui::TextInputType>(input_type),
 923       ui::TEXT_INPUT_MODE_DEFAULT,
 924       true));
 925
 926   ViewHostMsg_SelectionBounds_Params bounds_params;
 927   bounds_params.anchor_rect = bounds_params.focus_rect = caret_rect;
 928   bounds_params.anchor_dir = bounds_params.focus_dir =
 929       blink::WebTextDirectionLeftToRight;
 930   bounds_params.is_anchor_first = true;
 931   render_view_->Send(new ViewHostMsg_SelectionBoundsChanged(
 932       render_view_->routing_id(),
 933       bounds_params));
 934 }
 935 #endif
 936
 937 void WebPluginDelegateProxy::OnCancelResource(int id) {
 938   if (plugin_)
 939     plugin_->CancelResource(id);
 940 }
 941
 942 void WebPluginDelegateProxy::OnInvalidateRect(const gfx::Rect& rect) {
 943   if (!plugin_)
 944     return;
 945
 946   // Clip the invalidation rect to the plugin bounds; the plugin may have been
 947   // resized since the invalidate message was sent.
 948   gfx::Rect clipped_rect =
 949       gfx::IntersectRects(rect, gfx::Rect(plugin_rect_.size()));
 950
 951   invalidate_pending_ = true;
 952   // The plugin is blocked on the renderer because the invalidate message it has
 953   // sent us is synchronous, so we can use buffer flipping here if the caller
 954   // allows it.
 955   UpdateFrontBuffer(clipped_rect, true);
 956   plugin_->InvalidateRect(clipped_rect);
 957 }
 958
 959 void WebPluginDelegateProxy::OnGetWindowScriptNPObject(
 960     int route_id, bool* success) {
 961   *success = false;
 962   NPObject* npobject = NULL;
 963   if (plugin_)
 964     npobject = plugin_->GetWindowScriptNPObject();
 965
 966   if (!npobject)
 967     return;
 968
 969   // The stub will delete itself when the proxy tells it that it's released, or
 970   // otherwise when the channel is closed.
 971   new NPObjectStub(npobject, channel_host_.get(), route_id, 0, page_url_);
 972   *success = true;
 973 }
 974
 975 void WebPluginDelegateProxy::OnResolveProxy(const GURL& url,
 976                                             bool* result,
 977                                             std::string* proxy_list) {
 978   *result = RenderThreadImpl::current()->ResolveProxy(url, proxy_list);
 979 }
 980
 981 void WebPluginDelegateProxy::OnGetPluginElement(int route_id, bool* success) {
 982   *success = false;
 983   NPObject* npobject = NULL;
 984   if (plugin_)
 985     npobject = plugin_->GetPluginElement();
 986   if (!npobject)
 987     return;
 988
 989   // The stub will delete itself when the proxy tells it that it's released, or
 990   // otherwise when the channel is closed.
 991   new NPObjectStub(
 992       npobject, channel_host_.get(), route_id, 0, page_url_);
 993   *success = true;
 994 }
 995
 996 void WebPluginDelegateProxy::OnSetCookie(const GURL& url,
 997                                          const GURL& first_party_for_cookies,
 998                                          const std::string& cookie) {
 999   if (plugin_)
1000     plugin_->SetCookie(url, first_party_for_cookies, cookie);
1001 }
1002
1003 void WebPluginDelegateProxy::OnGetCookies(const GURL& url,
1004                                           const GURL& first_party_for_cookies,
1005                                           std::string* cookies) {
1006   DCHECK(cookies);
1007   if (plugin_)
1008     *cookies = plugin_->GetCookies(url, first_party_for_cookies);
1009 }
1010
1011 void WebPluginDelegateProxy::CopyFromBackBufferToFrontBuffer(
1012     const gfx::Rect& rect) {
1013 #if defined(OS_MACOSX)
1014   // Blitting the bits directly is much faster than going through CG, and since
1015   // the goal is just to move the raw pixels between two bitmaps with the same
1016   // pixel format (no compositing, color correction, etc.), it's safe.
1017   const size_t stride =
1018       skia::PlatformCanvasStrideForWidth(plugin_rect_.width());
1019   const size_t chunk_size = 4 * rect.width();
1020   DCHECK(back_buffer_dib() != NULL);
1021   uint8* source_data = static_cast<uint8*>(back_buffer_dib()->memory()) +
1022                        rect.y() * stride + 4 * rect.x();
1023   DCHECK(front_buffer_dib() != NULL);
1024   uint8* target_data = static_cast<uint8*>(front_buffer_dib()->memory()) +
1025                        rect.y() * stride + 4 * rect.x();
1026   for (int row = 0; row < rect.height(); ++row) {
1027     memcpy(target_data, source_data, chunk_size);
1028     source_data += stride;
1029     target_data += stride;
1030   }
1031 #else
1032   BlitCanvasToCanvas(front_buffer_canvas(),
1033                      rect,
1034                      back_buffer_canvas(),
1035                      rect.origin());
1036 #endif
1037 }
1038
1039 void WebPluginDelegateProxy::UpdateFrontBuffer(
1040     const gfx::Rect& rect,
1041     bool allow_buffer_flipping) {
1042   if (!front_buffer_canvas()) {
1043     return;
1044   }
1045
1046 #if defined(OS_WIN)
1047   // If SendUpdateGeometry() would block on the plugin process then we don't
1048   // want to use buffer flipping at all since it would add extra locking.
1049   // (Alternatively we could probably safely use async updates for buffer
1050   // flipping all the time since the size is not changing.)
1051   if (UseSynchronousGeometryUpdates()) {
1052     allow_buffer_flipping = false;
1053   }
1054 #endif
1055
1056   // Plugin has just painted "rect" into the back-buffer, so the front-buffer
1057   // no longer holds the latest content for that rectangle.
1058   front_buffer_diff_.Subtract(rect);
1059   if (allow_buffer_flipping && front_buffer_diff_.IsEmpty()) {
1060     // Back-buffer contains the latest content for all areas; simply flip
1061     // the buffers.
1062     front_buffer_index_ = back_buffer_index();
1063     SendUpdateGeometry(false);
1064     // The front-buffer now holds newer content for this region than the
1065     // back-buffer.
1066     front_buffer_diff_ = rect;
1067   } else {
1068     // Back-buffer contains the latest content for "rect" but the front-buffer
1069     // contains the latest content for some other areas (or buffer flipping not
1070     // allowed); fall back to copying the data.
1071     CopyFromBackBufferToFrontBuffer(rect);
1072   }
1073   transport_store_painted_.Union(rect);
1074 }
1075
1076 void WebPluginDelegateProxy::OnHandleURLRequest(
1077     const PluginHostMsg_URLRequest_Params& params) {
1078   const char* data = NULL;
1079   if (params.buffer.size())
1080     data = &params.buffer[0];
1081
1082   const char* target = NULL;
1083   if (params.target.length())
1084     target = params.target.c_str();
1085
1086   plugin_->HandleURLRequest(
1087       params.url.c_str(), params.method.c_str(), target, data,
1088       static_cast<unsigned int>(params.buffer.size()), params.notify_id,
1089       params.popups_allowed, params.notify_redirects);
1090 }
1091
1092 WebPluginResourceClient* WebPluginDelegateProxy::CreateResourceClient(
1093     unsigned long resource_id, const GURL& url, int notify_id) {
1094   if (!channel_host_.get())
1095     return NULL;
1096
1097   ResourceClientProxy* proxy =
1098       new ResourceClientProxy(channel_host_.get(), instance_id_);
1099   proxy->Initialize(resource_id, url, notify_id);
1100   return proxy;
1101 }
1102
1103 WebPluginResourceClient* WebPluginDelegateProxy::CreateSeekableResourceClient(
1104     unsigned long resource_id, int range_request_id) {
1105   if (!channel_host_.get())
1106     return NULL;
1107
1108   ResourceClientProxy* proxy =
1109       new ResourceClientProxy(channel_host_.get(), instance_id_);
1110   proxy->InitializeForSeekableStream(resource_id, range_request_id);
1111   return proxy;
1112 }
1113
1114 void WebPluginDelegateProxy::FetchURL(unsigned long resource_id,
1115                                       int notify_id,
1116                                       const GURL& url,
1117                                       const GURL& first_party_for_cookies,
1118                                       const std::string& method,
1119                                       const char* buf,
1120                                       unsigned int len,
1121                                       const GURL& referrer,
1122                                       bool notify_redirects,
1123                                       bool is_plugin_src_load,
1124                                       int origin_pid,
1125                                       int render_frame_id,
1126                                       int render_view_id) {
1127   PluginMsg_FetchURL_Params params;
1128   params.resource_id = resource_id;
1129   params.notify_id = notify_id;
1130   params.url = url;
1131   params.first_party_for_cookies = first_party_for_cookies;
1132   params.method = method;
1133   if (len) {
1134     params.post_data.resize(len);
1135     memcpy(&params.post_data.front(), buf, len);
1136   }
1137   params.referrer = referrer;
1138   params.notify_redirect = notify_redirects;
1139   params.is_plugin_src_load = is_plugin_src_load;
1140   params.render_frame_id = render_frame_id;
1141   Send(new PluginMsg_FetchURL(instance_id_, params));
1142 }
1143
1144 #if defined(OS_MACOSX)
1145 void WebPluginDelegateProxy::OnFocusChanged(bool focused) {
1146   if (render_view_)
1147     render_view_->PluginFocusChanged(focused, instance_id_);
1148 }
1149
1150 void WebPluginDelegateProxy::OnStartIme() {
1151   if (render_view_)
1152     render_view_->StartPluginIme();
1153 }
1154 #endif
1155
1156 gfx::PluginWindowHandle WebPluginDelegateProxy::GetPluginWindowHandle() {
1157   return window_;
1158 }
1159
1160 void WebPluginDelegateProxy::OnCancelDocumentLoad() {
1161   plugin_->CancelDocumentLoad();
1162 }
1163
1164 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
1165     const std::string& url,
1166     const std::string& range_info,
1167     int range_request_id) {
1168   plugin_->InitiateHTTPRangeRequest(
1169       url.c_str(), range_info.c_str(), range_request_id);
1170 }
1171
1172 void WebPluginDelegateProxy::OnDidStartLoading() {
1173   plugin_->DidStartLoading();
1174 }
1175
1176 void WebPluginDelegateProxy::OnDidStopLoading() {
1177   plugin_->DidStopLoading();
1178 }
1179
1180 void WebPluginDelegateProxy::OnDeferResourceLoading(unsigned long resource_id,
1181                                                     bool defer) {
1182   plugin_->SetDeferResourceLoading(resource_id, defer);
1183 }
1184
1185 #if defined(OS_MACOSX)
1186 void WebPluginDelegateProxy::OnAcceleratedPluginEnabledRendering() {
1187   uses_compositor_ = true;
1188   OnSetWindow(gfx::kNullPluginWindow);
1189 }
1190
1191 void WebPluginDelegateProxy::OnAcceleratedPluginAllocatedIOSurface(
1192     int32 width,
1193     int32 height,
1194     uint32 surface_id) {
1195   if (plugin_)
1196     plugin_->AcceleratedPluginAllocatedIOSurface(width, height, surface_id);
1197 }
1198
1199 void WebPluginDelegateProxy::OnAcceleratedPluginSwappedIOSurface() {
1200   if (plugin_)
1201     plugin_->AcceleratedPluginSwappedIOSurface();
1202 }
1203 #endif
1204
1205 #if defined(OS_WIN)
1206 bool WebPluginDelegateProxy::UseSynchronousGeometryUpdates() {
1207   // Need to update geometry synchronously with WMP, otherwise if a site
1208   // scripts the plugin to start playing while it's in the middle of handling
1209   // an update geometry message, videos don't play.  See urls in bug 20260.
1210   if (info_.name.find(base::ASCIIToUTF16("Windows Media Player")) !=
1211       base::string16::npos)
1212     return true;
1213
1214   // The move networks plugin needs to be informed of geometry updates
1215   // synchronously.
1216   std::vector<WebPluginMimeType>::iterator index;
1217   for (index = info_.mime_types.begin(); index != info_.mime_types.end();
1218        index++) {
1219     if (index->mime_type == "application/x-vnd.moveplayer.qm" ||
1220         index->mime_type == "application/x-vnd.moveplay2.qm" ||
1221         index->mime_type == "application/x-vnd.movenetworks.qm" ||
1222         index->mime_type == "application/x-vnd.mnplayer.qm") {
1223       return true;
1224     }
1225   }
1226   return false;
1227 }
1228 #endif
1229
1230 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
1231                                                    int resource_id) {
1232   if (!plugin_)
1233     return;
1234
1235   plugin_->URLRedirectResponse(allow, resource_id);
1236 }
1237
1238 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
1239                                                          bool* result) {
1240   *result = plugin_->CheckIfRunInsecureContent(url);
1241 }
1242
1243 }  // namespace content