Home | History | Annotate | Download | only in npapi 
      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   ViewHostMsg_TextInputState_Params p;
    921   p.type = static_cast<ui::TextInputType>(input_type);
    922   p.mode = ui::TEXT_INPUT_MODE_DEFAULT;
    923   p.can_compose_inline = true;
    924 
    925   render_view_->Send(new ViewHostMsg_TextInputStateChanged(
    926       render_view_->routing_id(), p));
    927 
    928   ViewHostMsg_SelectionBounds_Params bounds_params;
    929   bounds_params.anchor_rect = bounds_params.focus_rect = caret_rect;
    930   bounds_params.anchor_dir = bounds_params.focus_dir =
    931       blink::WebTextDirectionLeftToRight;
    932   bounds_params.is_anchor_first = true;
    933   render_view_->Send(new ViewHostMsg_SelectionBoundsChanged(
    934       render_view_->routing_id(),
    935       bounds_params));
    936 }
    937 #endif
    938 
    939 void WebPluginDelegateProxy::OnCancelResource(int id) {
    940   if (plugin_)
    941     plugin_->CancelResource(id);
    942 }
    943 
    944 void WebPluginDelegateProxy::OnInvalidateRect(const gfx::Rect& rect) {
    945   if (!plugin_)
    946     return;
    947 
    948   // Clip the invalidation rect to the plugin bounds; the plugin may have been
    949   // resized since the invalidate message was sent.
    950   gfx::Rect clipped_rect =
    951       gfx::IntersectRects(rect, gfx::Rect(plugin_rect_.size()));
    952 
    953   invalidate_pending_ = true;
    954   // The plugin is blocked on the renderer because the invalidate message it has
    955   // sent us is synchronous, so we can use buffer flipping here if the caller
    956   // allows it.
    957   UpdateFrontBuffer(clipped_rect, true);
    958   plugin_->InvalidateRect(clipped_rect);
    959 }
    960 
    961 void WebPluginDelegateProxy::OnGetWindowScriptNPObject(
    962     int route_id, bool* success) {
    963   *success = false;
    964   NPObject* npobject = NULL;
    965   if (plugin_)
    966     npobject = plugin_->GetWindowScriptNPObject();
    967 
    968   if (!npobject)
    969     return;
    970 
    971   // The stub will delete itself when the proxy tells it that it's released, or
    972   // otherwise when the channel is closed.
    973   new NPObjectStub(npobject, channel_host_.get(), route_id, 0, page_url_);
    974   *success = true;
    975 }
    976 
    977 void WebPluginDelegateProxy::OnResolveProxy(const GURL& url,
    978                                             bool* result,
    979                                             std::string* proxy_list) {
    980   *result = RenderThreadImpl::current()->ResolveProxy(url, proxy_list);
    981 }
    982 
    983 void WebPluginDelegateProxy::OnGetPluginElement(int route_id, bool* success) {
    984   *success = false;
    985   NPObject* npobject = NULL;
    986   if (plugin_)
    987     npobject = plugin_->GetPluginElement();
    988   if (!npobject)
    989     return;
    990 
    991   // The stub will delete itself when the proxy tells it that it's released, or
    992   // otherwise when the channel is closed.
    993   new NPObjectStub(
    994       npobject, channel_host_.get(), route_id, 0, page_url_);
    995   *success = true;
    996 }
    997 
    998 void WebPluginDelegateProxy::OnSetCookie(const GURL& url,
    999                                          const GURL& first_party_for_cookies,
   1000                                          const std::string& cookie) {
   1001   if (plugin_)
   1002     plugin_->SetCookie(url, first_party_for_cookies, cookie);
   1003 }
   1004 
   1005 void WebPluginDelegateProxy::OnGetCookies(const GURL& url,
   1006                                           const GURL& first_party_for_cookies,
   1007                                           std::string* cookies) {
   1008   DCHECK(cookies);
   1009   if (plugin_)
   1010     *cookies = plugin_->GetCookies(url, first_party_for_cookies);
   1011 }
   1012 
   1013 void WebPluginDelegateProxy::CopyFromBackBufferToFrontBuffer(
   1014     const gfx::Rect& rect) {
   1015 #if defined(OS_MACOSX)
   1016   // Blitting the bits directly is much faster than going through CG, and since
   1017   // the goal is just to move the raw pixels between two bitmaps with the same
   1018   // pixel format (no compositing, color correction, etc.), it's safe.
   1019   const size_t stride =
   1020       skia::PlatformCanvasStrideForWidth(plugin_rect_.width());
   1021   const size_t chunk_size = 4 * rect.width();
   1022   DCHECK(back_buffer_dib() != NULL);
   1023   uint8* source_data = static_cast<uint8*>(back_buffer_dib()->memory()) +
   1024                        rect.y() * stride + 4 * rect.x();
   1025   DCHECK(front_buffer_dib() != NULL);
   1026   uint8* target_data = static_cast<uint8*>(front_buffer_dib()->memory()) +
   1027                        rect.y() * stride + 4 * rect.x();
   1028   for (int row = 0; row < rect.height(); ++row) {
   1029     memcpy(target_data, source_data, chunk_size);
   1030     source_data += stride;
   1031     target_data += stride;
   1032   }
   1033 #else
   1034   BlitCanvasToCanvas(front_buffer_canvas(),
   1035                      rect,
   1036                      back_buffer_canvas(),
   1037                      rect.origin());
   1038 #endif
   1039 }
   1040 
   1041 void WebPluginDelegateProxy::UpdateFrontBuffer(
   1042     const gfx::Rect& rect,
   1043     bool allow_buffer_flipping) {
   1044   if (!front_buffer_canvas()) {
   1045     return;
   1046   }
   1047 
   1048 #if defined(OS_WIN)
   1049   // If SendUpdateGeometry() would block on the plugin process then we don't
   1050   // want to use buffer flipping at all since it would add extra locking.
   1051   // (Alternatively we could probably safely use async updates for buffer
   1052   // flipping all the time since the size is not changing.)
   1053   if (UseSynchronousGeometryUpdates()) {
   1054     allow_buffer_flipping = false;
   1055   }
   1056 #endif
   1057 
   1058   // Plugin has just painted "rect" into the back-buffer, so the front-buffer
   1059   // no longer holds the latest content for that rectangle.
   1060   front_buffer_diff_.Subtract(rect);
   1061   if (allow_buffer_flipping && front_buffer_diff_.IsEmpty()) {
   1062     // Back-buffer contains the latest content for all areas; simply flip
   1063     // the buffers.
   1064     front_buffer_index_ = back_buffer_index();
   1065     SendUpdateGeometry(false);
   1066     // The front-buffer now holds newer content for this region than the
   1067     // back-buffer.
   1068     front_buffer_diff_ = rect;
   1069   } else {
   1070     // Back-buffer contains the latest content for "rect" but the front-buffer
   1071     // contains the latest content for some other areas (or buffer flipping not
   1072     // allowed); fall back to copying the data.
   1073     CopyFromBackBufferToFrontBuffer(rect);
   1074   }
   1075   transport_store_painted_.Union(rect);
   1076 }
   1077 
   1078 void WebPluginDelegateProxy::OnHandleURLRequest(
   1079     const PluginHostMsg_URLRequest_Params& params) {
   1080   const char* data = NULL;
   1081   if (params.buffer.size())
   1082     data = &params.buffer[0];
   1083 
   1084   const char* target = NULL;
   1085   if (params.target.length())
   1086     target = params.target.c_str();
   1087 
   1088   plugin_->HandleURLRequest(
   1089       params.url.c_str(), params.method.c_str(), target, data,
   1090       static_cast<unsigned int>(params.buffer.size()), params.notify_id,
   1091       params.popups_allowed, params.notify_redirects);
   1092 }
   1093 
   1094 WebPluginResourceClient* WebPluginDelegateProxy::CreateResourceClient(
   1095     unsigned long resource_id, const GURL& url, int notify_id) {
   1096   if (!channel_host_.get())
   1097     return NULL;
   1098 
   1099   ResourceClientProxy* proxy =
   1100       new ResourceClientProxy(channel_host_.get(), instance_id_);
   1101   proxy->Initialize(resource_id, url, notify_id);
   1102   return proxy;
   1103 }
   1104 
   1105 WebPluginResourceClient* WebPluginDelegateProxy::CreateSeekableResourceClient(
   1106     unsigned long resource_id, int range_request_id) {
   1107   if (!channel_host_.get())
   1108     return NULL;
   1109 
   1110   ResourceClientProxy* proxy =
   1111       new ResourceClientProxy(channel_host_.get(), instance_id_);
   1112   proxy->InitializeForSeekableStream(resource_id, range_request_id);
   1113   return proxy;
   1114 }
   1115 
   1116 void WebPluginDelegateProxy::FetchURL(unsigned long resource_id,
   1117                                       int notify_id,
   1118                                       const GURL& url,
   1119                                       const GURL& first_party_for_cookies,
   1120                                       const std::string& method,
   1121                                       const char* buf,
   1122                                       unsigned int len,
   1123                                       const GURL& referrer,
   1124                                       bool notify_redirects,
   1125                                       bool is_plugin_src_load,
   1126                                       int origin_pid,
   1127                                       int render_frame_id,
   1128                                       int render_view_id) {
   1129   PluginMsg_FetchURL_Params params;
   1130   params.resource_id = resource_id;
   1131   params.notify_id = notify_id;
   1132   params.url = url;
   1133   params.first_party_for_cookies = first_party_for_cookies;
   1134   params.method = method;
   1135   if (len) {
   1136     params.post_data.resize(len);
   1137     memcpy(&params.post_data.front(), buf, len);
   1138   }
   1139   params.referrer = referrer;
   1140   params.notify_redirect = notify_redirects;
   1141   params.is_plugin_src_load = is_plugin_src_load;
   1142   params.render_frame_id = render_frame_id;
   1143   Send(new PluginMsg_FetchURL(instance_id_, params));
   1144 }
   1145 
   1146 #if defined(OS_MACOSX)
   1147 void WebPluginDelegateProxy::OnFocusChanged(bool focused) {
   1148   if (render_view_)
   1149     render_view_->PluginFocusChanged(focused, instance_id_);
   1150 }
   1151 
   1152 void WebPluginDelegateProxy::OnStartIme() {
   1153   if (render_view_)
   1154     render_view_->StartPluginIme();
   1155 }
   1156 #endif
   1157 
   1158 gfx::PluginWindowHandle WebPluginDelegateProxy::GetPluginWindowHandle() {
   1159   return window_;
   1160 }
   1161 
   1162 void WebPluginDelegateProxy::OnCancelDocumentLoad() {
   1163   plugin_->CancelDocumentLoad();
   1164 }
   1165 
   1166 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
   1167     const std::string& url,
   1168     const std::string& range_info,
   1169     int range_request_id) {
   1170   plugin_->InitiateHTTPRangeRequest(
   1171       url.c_str(), range_info.c_str(), range_request_id);
   1172 }
   1173 
   1174 void WebPluginDelegateProxy::OnDidStartLoading() {
   1175   plugin_->DidStartLoading();
   1176 }
   1177 
   1178 void WebPluginDelegateProxy::OnDidStopLoading() {
   1179   plugin_->DidStopLoading();
   1180 }
   1181 
   1182 void WebPluginDelegateProxy::OnDeferResourceLoading(unsigned long resource_id,
   1183                                                     bool defer) {
   1184   plugin_->SetDeferResourceLoading(resource_id, defer);
   1185 }
   1186 
   1187 #if defined(OS_MACOSX)
   1188 void WebPluginDelegateProxy::OnAcceleratedPluginEnabledRendering() {
   1189   uses_compositor_ = true;
   1190   OnSetWindow(gfx::kNullPluginWindow);
   1191 }
   1192 
   1193 void WebPluginDelegateProxy::OnAcceleratedPluginAllocatedIOSurface(
   1194     int32 width,
   1195     int32 height,
   1196     uint32 surface_id) {
   1197   if (plugin_)
   1198     plugin_->AcceleratedPluginAllocatedIOSurface(width, height, surface_id);
   1199 }
   1200 
   1201 void WebPluginDelegateProxy::OnAcceleratedPluginSwappedIOSurface() {
   1202   if (plugin_)
   1203     plugin_->AcceleratedPluginSwappedIOSurface();
   1204 }
   1205 #endif
   1206 
   1207 #if defined(OS_WIN)
   1208 bool WebPluginDelegateProxy::UseSynchronousGeometryUpdates() {
   1209   // Need to update geometry synchronously with WMP, otherwise if a site
   1210   // scripts the plugin to start playing while it's in the middle of handling
   1211   // an update geometry message, videos don't play.  See urls in bug 20260.
   1212   if (info_.name.find(base::ASCIIToUTF16("Windows Media Player")) !=
   1213       base::string16::npos)
   1214     return true;
   1215 
   1216   // The move networks plugin needs to be informed of geometry updates
   1217   // synchronously.
   1218   std::vector<WebPluginMimeType>::iterator index;
   1219   for (index = info_.mime_types.begin(); index != info_.mime_types.end();
   1220        index++) {
   1221     if (index->mime_type == "application/x-vnd.moveplayer.qm" ||
   1222         index->mime_type == "application/x-vnd.moveplay2.qm" ||
   1223         index->mime_type == "application/x-vnd.movenetworks.qm" ||
   1224         index->mime_type == "application/x-vnd.mnplayer.qm") {
   1225       return true;
   1226     }
   1227   }
   1228   return false;
   1229 }
   1230 #endif
   1231 
   1232 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
   1233                                                    int resource_id) {
   1234   if (!plugin_)
   1235     return;
   1236 
   1237   plugin_->URLRedirectResponse(allow, resource_id);
   1238 }
   1239 
   1240 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
   1241                                                          bool* result) {
   1242   *result = plugin_->CheckIfRunInsecureContent(url);
   1243 }
   1244 
   1245 }  // namespace content
   1246