• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/files/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 
ScopedLogLevel(int level)86 ScopedLogLevel::ScopedLogLevel(int level)
87     : old_level_(logging::GetMinLogLevel()) {
88   logging::SetMinLogLevel(level);
89 }
90 
~ScopedLogLevel()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:
ResourceClientProxy(PluginChannelHost * channel,int instance_id)99   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
100     : channel_(channel), instance_id_(instance_id), resource_id_(0),
101       multibyte_response_expected_(false) {
102   }
103 
~ResourceClientProxy()104   virtual ~ResourceClientProxy() {
105   }
106 
Initialize(unsigned long resource_id,const GURL & url,int notify_id)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 
InitializeForSeekableStream(unsigned long resource_id,int range_request_id)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:
WillSendRequest(const GURL & url,int http_status_code)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 
DidReceiveResponse(const std::string & mime_type,const std::string & headers,uint32 expected_length,uint32 last_modified,bool request_is_seekable)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 
DidReceiveData(const char * buffer,int length,int data_offset)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 
DidFinishLoading(unsigned long resource_id)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 
DidFail(unsigned long resource_id)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 
IsMultiByteResponseExpected()178   virtual bool IsMultiByteResponseExpected() OVERRIDE {
179     return multibyte_response_expected_;
180   }
181 
ResourceId()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 
WebPluginDelegateProxy(WebPluginImpl * plugin,const std::string & mime_type,const base::WeakPtr<RenderViewImpl> & render_view,RenderFrameImpl * render_frame)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 
~WebPluginDelegateProxy()223 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
224   if (npobject_)
225     WebBindings::releaseObject(npobject_);
226 }
227 
SharedBitmap()228 WebPluginDelegateProxy::SharedBitmap::SharedBitmap() {}
229 
~SharedBitmap()230 WebPluginDelegateProxy::SharedBitmap::~SharedBitmap() {}
231 
PluginDestroyed()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 
Initialize(const GURL & url,const std::vector<std::string> & arg_names,const std::vector<std::string> & arg_values,bool load_manually)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_->GetMainRenderFrame()->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 
Send(IPC::Message * msg)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 
SendJavaScriptStream(const GURL & url,const std::string & result,bool success,int notify_id)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 
DidReceiveManualResponse(const GURL & url,const std::string & mime_type,const std::string & headers,uint32 expected_length,uint32 last_modified)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 
DidReceiveManualData(const char * buffer,int length)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 
DidFinishManualLoading()424 void WebPluginDelegateProxy::DidFinishManualLoading() {
425   Send(new PluginMsg_DidFinishManualLoading(instance_id_));
426 }
427 
DidManualLoadFail()428 void WebPluginDelegateProxy::DidManualLoadFail() {
429   Send(new PluginMsg_DidManualLoadFail(instance_id_));
430 }
431 
OnMessageReceived(const IPC::Message & msg)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 
OnChannelError()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_.get() && !channel_host_->expecting_shutdown()) {
490     render_view_->GetMainRenderFrame()->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 
CopyTransportDIBHandleForMessage(const TransportDIB::Handle & handle_in,TransportDIB::Handle * handle_out,base::ProcessId peer_pid)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 
SendUpdateGeometry(bool bitmaps_changed)526 void WebPluginDelegateProxy::SendUpdateGeometry(
527     bool bitmaps_changed) {
528   if (!channel_host_.get())
529     return;
530 
531   PluginMsg_UpdateGeometry_Param param;
532   param.window_rect = plugin_rect_;
533   param.clip_rect = clip_rect_;
534   param.windowless_buffer0 = TransportDIB::DefaultHandleValue();
535   param.windowless_buffer1 = TransportDIB::DefaultHandleValue();
536   param.windowless_buffer_index = back_buffer_index();
537 
538 #if defined(OS_POSIX)
539   // If we're using POSIX mmap'd TransportDIBs, sending the handle across
540   // IPC establishes a new mapping rather than just sending a window ID,
541   // so only do so if we've actually changed the shared memory bitmaps.
542   if (bitmaps_changed)
543 #endif
544   {
545     if (transport_stores_[0].dib)
546       CopyTransportDIBHandleForMessage(transport_stores_[0].dib->handle(),
547                                        &param.windowless_buffer0,
548                                        channel_host_->peer_pid());
549 
550     if (transport_stores_[1].dib)
551       CopyTransportDIBHandleForMessage(transport_stores_[1].dib->handle(),
552                                        &param.windowless_buffer1,
553                                        channel_host_->peer_pid());
554   }
555 
556   IPC::Message* msg;
557 #if defined(OS_WIN)
558   if (UseSynchronousGeometryUpdates()) {
559     msg = new PluginMsg_UpdateGeometrySync(instance_id_, param);
560   } else  // NOLINT
561 #endif
562   {
563     msg = new PluginMsg_UpdateGeometry(instance_id_, param);
564     msg->set_unblock(true);
565   }
566 
567   Send(msg);
568 }
569 
UpdateGeometry(const gfx::Rect & window_rect,const gfx::Rect & clip_rect)570 void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect,
571                                             const gfx::Rect& clip_rect) {
572   // window_rect becomes either a window in native windowing system
573   // coords, or a backing buffer.  In either case things will go bad
574   // if the rectangle is very large.
575   if (window_rect.width() < 0  || window_rect.width() > kMaxPluginSideLength ||
576       window_rect.height() < 0 || window_rect.height() > kMaxPluginSideLength ||
577       // We know this won't overflow due to above checks.
578       static_cast<uint32>(window_rect.width()) *
579           static_cast<uint32>(window_rect.height()) > kMaxPluginSize) {
580     return;
581   }
582 
583   plugin_rect_ = window_rect;
584   clip_rect_ = clip_rect;
585 
586   bool bitmaps_changed = false;
587 
588   if (uses_shared_bitmaps_) {
589     if (!front_buffer_canvas() ||
590         (window_rect.width() != front_buffer_canvas()->getDevice()->width() ||
591          window_rect.height() != front_buffer_canvas()->getDevice()->height()))
592     {
593       bitmaps_changed = true;
594 
595       // Create a shared memory section that the plugin paints into
596       // asynchronously.
597       ResetWindowlessBitmaps();
598       if (!window_rect.IsEmpty()) {
599         if (!CreateSharedBitmap(&transport_stores_[0].dib,
600                                 &transport_stores_[0].canvas) ||
601             !CreateSharedBitmap(&transport_stores_[1].dib,
602                                 &transport_stores_[1].canvas)) {
603           DCHECK(false);
604           ResetWindowlessBitmaps();
605           return;
606         }
607       }
608     }
609   }
610 
611   SendUpdateGeometry(bitmaps_changed);
612 }
613 
ResetWindowlessBitmaps()614 void WebPluginDelegateProxy::ResetWindowlessBitmaps() {
615   transport_stores_[0].dib.reset();
616   transport_stores_[1].dib.reset();
617 
618   transport_stores_[0].canvas.reset();
619   transport_stores_[1].canvas.reset();
620   transport_store_painted_ = gfx::Rect();
621   front_buffer_diff_ = gfx::Rect();
622 }
623 
BitmapSizeForPluginRect(const gfx::Rect & plugin_rect)624 static size_t BitmapSizeForPluginRect(const gfx::Rect& plugin_rect) {
625   const size_t stride =
626       skia::PlatformCanvasStrideForWidth(plugin_rect.width());
627   return stride * plugin_rect.height();
628 }
629 
630 #if !defined(OS_WIN)
CreateLocalBitmap(std::vector<uint8> * memory,scoped_ptr<skia::PlatformCanvas> * canvas)631 bool WebPluginDelegateProxy::CreateLocalBitmap(
632     std::vector<uint8>* memory,
633     scoped_ptr<skia::PlatformCanvas>* canvas) {
634   const size_t size = BitmapSizeForPluginRect(plugin_rect_);
635   memory->resize(size);
636   if (memory->size() != size)
637     return false;
638   canvas->reset(skia::CreatePlatformCanvas(
639       plugin_rect_.width(), plugin_rect_.height(), true, &((*memory)[0]),
640       skia::CRASH_ON_FAILURE));
641   return true;
642 }
643 #endif
644 
CreateSharedBitmap(scoped_ptr<TransportDIB> * memory,scoped_ptr<skia::PlatformCanvas> * canvas)645 bool WebPluginDelegateProxy::CreateSharedBitmap(
646     scoped_ptr<TransportDIB>* memory,
647     scoped_ptr<skia::PlatformCanvas>* canvas) {
648   const size_t size = BitmapSizeForPluginRect(plugin_rect_);
649 #if defined(OS_POSIX) && !defined(OS_MACOSX)
650   memory->reset(TransportDIB::Create(size, 0));
651   if (!memory->get())
652     return false;
653 #endif
654 #if defined(OS_POSIX) && !defined(OS_ANDROID)
655   TransportDIB::Handle handle;
656   IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(size, false, &handle);
657   if (!RenderThreadImpl::current()->Send(msg))
658     return false;
659   if (handle.fd < 0)
660     return false;
661   memory->reset(TransportDIB::Map(handle));
662 #else
663   static uint32 sequence_number = 0;
664   memory->reset(TransportDIB::Create(size, sequence_number++));
665 #endif
666   canvas->reset((*memory)->GetPlatformCanvas(plugin_rect_.width(),
667                                              plugin_rect_.height()));
668   return !!canvas->get();
669 }
670 
Paint(SkCanvas * canvas,const gfx::Rect & damaged_rect)671 void WebPluginDelegateProxy::Paint(SkCanvas* canvas,
672                                    const gfx::Rect& damaged_rect) {
673   // Limit the damaged rectangle to whatever is contained inside the plugin
674   // rectangle, as that's the rectangle that we'll actually draw.
675   gfx::Rect rect = gfx::IntersectRects(damaged_rect, plugin_rect_);
676 
677   // If the plugin is no longer connected (channel crashed) draw a crashed
678   // plugin bitmap
679   if (!channel_host_.get() || !channel_host_->channel_valid()) {
680     // Lazily load the sad plugin image.
681     if (!sad_plugin_)
682       sad_plugin_ = GetContentClient()->renderer()->GetSadPluginBitmap();
683     if (sad_plugin_)
684       PaintSadPlugin(canvas, plugin_rect_, *sad_plugin_);
685     return;
686   }
687 
688   if (!uses_shared_bitmaps_)
689     return;
690 
691   // We got a paint before the plugin's coordinates, so there's no buffer to
692   // copy from.
693   if (!front_buffer_canvas())
694     return;
695 
696   gfx::Rect offset_rect = rect;
697   offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
698 
699   // transport_store_painted_ is really a bounding box, so in principle this
700   // check could falsely indicate that we don't need to paint offset_rect, but
701   // in practice it works fine.
702   if (!transport_store_painted_.Contains(offset_rect)) {
703     Send(new PluginMsg_Paint(instance_id_, offset_rect));
704     // Since the plugin is not blocked on the renderer in this context, there is
705     // a chance that it will begin repainting the back-buffer before we complete
706     // capturing the data. Buffer flipping would increase that risk because
707     // geometry update is asynchronous, so we don't want to use buffer flipping
708     // here.
709     UpdateFrontBuffer(offset_rect, false);
710   }
711 
712   const SkBitmap& bitmap =
713       front_buffer_canvas()->getDevice()->accessBitmap(false);
714   SkPaint paint;
715   paint.setXfermodeMode(
716       transparent_ ? SkXfermode::kSrcATop_Mode : SkXfermode::kSrc_Mode);
717   SkIRect src_rect = gfx::RectToSkIRect(offset_rect);
718   canvas->drawBitmapRect(bitmap,
719                          &src_rect,
720                          gfx::RectToSkRect(rect),
721                          &paint);
722 
723   if (invalidate_pending_) {
724     // Only send the PaintAck message if this paint is in response to an
725     // invalidate from the plugin, since this message acts as an access token
726     // to ensure only one process is using the transport dib at a time.
727     invalidate_pending_ = false;
728     Send(new PluginMsg_DidPaint(instance_id_));
729   }
730 }
731 
GetPluginScriptableObject()732 NPObject* WebPluginDelegateProxy::GetPluginScriptableObject() {
733   if (npobject_)
734     return WebBindings::retainObject(npobject_);
735 
736   if (!channel_host_.get())
737     return NULL;
738 
739   int route_id = MSG_ROUTING_NONE;
740   Send(new PluginMsg_GetPluginScriptableObject(instance_id_, &route_id));
741   if (route_id == MSG_ROUTING_NONE)
742     return NULL;
743 
744   npobject_ = NPObjectProxy::Create(
745       channel_host_.get(), route_id, 0, page_url_, GetPluginNPP());
746 
747   return WebBindings::retainObject(npobject_);
748 }
749 
GetPluginNPP()750 NPP WebPluginDelegateProxy::GetPluginNPP() {
751   // Return a dummy NPP for WebKit to use to identify this plugin.
752   return npp_.get();
753 }
754 
GetFormValue(base::string16 * value)755 bool WebPluginDelegateProxy::GetFormValue(base::string16* value) {
756   bool success = false;
757   Send(new PluginMsg_GetFormValue(instance_id_, value, &success));
758   return success;
759 }
760 
DidFinishLoadWithReason(const GURL & url,NPReason reason,int notify_id)761 void WebPluginDelegateProxy::DidFinishLoadWithReason(
762     const GURL& url, NPReason reason, int notify_id) {
763   Send(new PluginMsg_DidFinishLoadWithReason(
764       instance_id_, url, reason, notify_id));
765 }
766 
SetFocus(bool focused)767 void WebPluginDelegateProxy::SetFocus(bool focused) {
768   Send(new PluginMsg_SetFocus(instance_id_, focused));
769 #if defined(OS_WIN)
770   if (render_view_)
771     render_view_->PluginFocusChanged(focused, instance_id_);
772 #endif
773 }
774 
HandleInputEvent(const WebInputEvent & event,WebCursor::CursorInfo * cursor_info)775 bool WebPluginDelegateProxy::HandleInputEvent(
776     const WebInputEvent& event,
777     WebCursor::CursorInfo* cursor_info) {
778   bool handled = false;
779   WebCursor cursor;
780   // A windowless plugin can enter a modal loop in the context of a
781   // NPP_HandleEvent call, in which case we need to pump messages to
782   // the plugin. We pass of the corresponding event handle to the
783   // plugin process, which is set if the plugin does enter a modal loop.
784   IPC::SyncMessage* message = new PluginMsg_HandleInputEvent(
785       instance_id_, &event, &handled, &cursor);
786   message->set_pump_messages_event(modal_loop_pump_messages_event_.get());
787   Send(message);
788   return handled;
789 }
790 
GetProcessId()791 int WebPluginDelegateProxy::GetProcessId() {
792   return channel_host_->peer_pid();
793 }
794 
SetContentAreaFocus(bool has_focus)795 void WebPluginDelegateProxy::SetContentAreaFocus(bool has_focus) {
796   IPC::Message* msg = new PluginMsg_SetContentAreaFocus(instance_id_,
797                                                         has_focus);
798   // Make sure focus events are delivered in the right order relative to
799   // sync messages they might interact with (Paint, HandleEvent, etc.).
800   msg->set_unblock(true);
801   Send(msg);
802 }
803 
804 #if defined(OS_WIN)
ImeCompositionUpdated(const base::string16 & text,const std::vector<int> & clauses,const std::vector<int> & target,int cursor_position,int plugin_id)805 void WebPluginDelegateProxy::ImeCompositionUpdated(
806     const base::string16& text,
807     const std::vector<int>& clauses,
808     const std::vector<int>& target,
809     int cursor_position,
810     int plugin_id) {
811   // Dispatch the raw IME data if this plug-in is the focused one.
812   if (instance_id_ != plugin_id)
813     return;
814 
815   IPC::Message* msg = new PluginMsg_ImeCompositionUpdated(instance_id_,
816       text, clauses, target, cursor_position);
817   msg->set_unblock(true);
818   Send(msg);
819 }
820 
ImeCompositionCompleted(const base::string16 & text,int plugin_id)821 void WebPluginDelegateProxy::ImeCompositionCompleted(const base::string16& text,
822                                                      int plugin_id) {
823   // Dispatch the IME text if this plug-in is the focused one.
824   if (instance_id_ != plugin_id)
825     return;
826 
827   IPC::Message* msg = new PluginMsg_ImeCompositionCompleted(instance_id_, text);
828   msg->set_unblock(true);
829   Send(msg);
830 }
831 #endif
832 
833 #if defined(OS_MACOSX)
SetWindowFocus(bool window_has_focus)834 void WebPluginDelegateProxy::SetWindowFocus(bool window_has_focus) {
835   IPC::Message* msg = new PluginMsg_SetWindowFocus(instance_id_,
836                                                    window_has_focus);
837   // Make sure focus events are delivered in the right order relative to
838   // sync messages they might interact with (Paint, HandleEvent, etc.).
839   msg->set_unblock(true);
840   Send(msg);
841 }
842 
SetContainerVisibility(bool is_visible)843 void WebPluginDelegateProxy::SetContainerVisibility(bool is_visible) {
844   IPC::Message* msg;
845   if (is_visible) {
846     gfx::Rect window_frame = render_view_->rootWindowRect();
847     gfx::Rect view_frame = render_view_->windowRect();
848     blink::WebView* webview = render_view_->webview();
849     msg = new PluginMsg_ContainerShown(instance_id_, window_frame, view_frame,
850                                        webview && webview->isActive());
851   } else {
852     msg = new PluginMsg_ContainerHidden(instance_id_);
853   }
854   // Make sure visibility events are delivered in the right order relative to
855   // sync messages they might interact with (Paint, HandleEvent, etc.).
856   msg->set_unblock(true);
857   Send(msg);
858 }
859 
WindowFrameChanged(gfx::Rect window_frame,gfx::Rect view_frame)860 void WebPluginDelegateProxy::WindowFrameChanged(gfx::Rect window_frame,
861                                                 gfx::Rect view_frame) {
862   IPC::Message* msg = new PluginMsg_WindowFrameChanged(instance_id_,
863                                                        window_frame,
864                                                        view_frame);
865   // Make sure frame events are delivered in the right order relative to
866   // sync messages they might interact with (e.g., HandleEvent).
867   msg->set_unblock(true);
868   Send(msg);
869 }
ImeCompositionCompleted(const base::string16 & text,int plugin_id)870 void WebPluginDelegateProxy::ImeCompositionCompleted(const base::string16& text,
871                                                      int plugin_id) {
872   // If the message isn't intended for this plugin, there's nothing to do.
873   if (instance_id_ != plugin_id)
874     return;
875 
876   IPC::Message* msg = new PluginMsg_ImeCompositionCompleted(instance_id_,
877                                                             text);
878   // Order relative to other key events is important.
879   msg->set_unblock(true);
880   Send(msg);
881 }
882 #endif  // OS_MACOSX
883 
OnSetWindow(gfx::PluginWindowHandle window)884 void WebPluginDelegateProxy::OnSetWindow(gfx::PluginWindowHandle window) {
885 #if defined(OS_MACOSX)
886   uses_shared_bitmaps_ = !window && !uses_compositor_;
887 #else
888   uses_shared_bitmaps_ = !window;
889 #endif
890   window_ = window;
891   if (plugin_)
892     plugin_->SetWindow(window);
893 }
894 
WillDestroyWindow()895 void WebPluginDelegateProxy::WillDestroyWindow() {
896   DCHECK(window_);
897   plugin_->WillDestroyWindow(window_);
898   window_ = gfx::kNullPluginWindow;
899 }
900 
901 #if defined(OS_WIN)
OnSetWindowlessData(HANDLE modal_loop_pump_messages_event,gfx::NativeViewId dummy_activation_window)902 void WebPluginDelegateProxy::OnSetWindowlessData(
903       HANDLE modal_loop_pump_messages_event,
904       gfx::NativeViewId dummy_activation_window) {
905   DCHECK(modal_loop_pump_messages_event_ == NULL);
906   DCHECK(dummy_activation_window_ == NULL);
907 
908   dummy_activation_window_ = dummy_activation_window;
909   render_view_->Send(new ViewHostMsg_WindowlessPluginDummyWindowCreated(
910       render_view_->routing_id(), dummy_activation_window_));
911 
912   // Bug 25583: this can be null because some "virus scanners" block the
913   // DuplicateHandle call in the plugin process.
914   if (!modal_loop_pump_messages_event)
915     return;
916 
917   modal_loop_pump_messages_event_.reset(
918       new base::WaitableEvent(modal_loop_pump_messages_event));
919 }
920 
OnNotifyIMEStatus(int input_type,const gfx::Rect & caret_rect)921 void WebPluginDelegateProxy::OnNotifyIMEStatus(int input_type,
922                                                const gfx::Rect& caret_rect) {
923   if (!render_view_)
924     return;
925 
926   render_view_->Send(new ViewHostMsg_TextInputTypeChanged(
927       render_view_->routing_id(),
928       static_cast<ui::TextInputType>(input_type),
929       ui::TEXT_INPUT_MODE_DEFAULT,
930       true));
931 
932   ViewHostMsg_SelectionBounds_Params bounds_params;
933   bounds_params.anchor_rect = bounds_params.focus_rect = caret_rect;
934   bounds_params.anchor_dir = bounds_params.focus_dir =
935       blink::WebTextDirectionLeftToRight;
936   bounds_params.is_anchor_first = true;
937   render_view_->Send(new ViewHostMsg_SelectionBoundsChanged(
938       render_view_->routing_id(),
939       bounds_params));
940 }
941 #endif
942 
OnCancelResource(int id)943 void WebPluginDelegateProxy::OnCancelResource(int id) {
944   if (plugin_)
945     plugin_->CancelResource(id);
946 }
947 
OnInvalidateRect(const gfx::Rect & rect)948 void WebPluginDelegateProxy::OnInvalidateRect(const gfx::Rect& rect) {
949   if (!plugin_)
950     return;
951 
952   // Clip the invalidation rect to the plugin bounds; the plugin may have been
953   // resized since the invalidate message was sent.
954   gfx::Rect clipped_rect =
955       gfx::IntersectRects(rect, gfx::Rect(plugin_rect_.size()));
956 
957   invalidate_pending_ = true;
958   // The plugin is blocked on the renderer because the invalidate message it has
959   // sent us is synchronous, so we can use buffer flipping here if the caller
960   // allows it.
961   UpdateFrontBuffer(clipped_rect, true);
962   plugin_->InvalidateRect(clipped_rect);
963 }
964 
OnGetWindowScriptNPObject(int route_id,bool * success)965 void WebPluginDelegateProxy::OnGetWindowScriptNPObject(
966     int route_id, bool* success) {
967   *success = false;
968   NPObject* npobject = NULL;
969   if (plugin_)
970     npobject = plugin_->GetWindowScriptNPObject();
971 
972   if (!npobject)
973     return;
974 
975   // The stub will delete itself when the proxy tells it that it's released, or
976   // otherwise when the channel is closed.
977   new NPObjectStub(npobject, channel_host_.get(), route_id, 0, page_url_);
978   *success = true;
979 }
980 
OnResolveProxy(const GURL & url,bool * result,std::string * proxy_list)981 void WebPluginDelegateProxy::OnResolveProxy(const GURL& url,
982                                             bool* result,
983                                             std::string* proxy_list) {
984   *result = RenderThreadImpl::current()->ResolveProxy(url, proxy_list);
985 }
986 
OnGetPluginElement(int route_id,bool * success)987 void WebPluginDelegateProxy::OnGetPluginElement(int route_id, bool* success) {
988   *success = false;
989   NPObject* npobject = NULL;
990   if (plugin_)
991     npobject = plugin_->GetPluginElement();
992   if (!npobject)
993     return;
994 
995   // The stub will delete itself when the proxy tells it that it's released, or
996   // otherwise when the channel is closed.
997   new NPObjectStub(
998       npobject, channel_host_.get(), route_id, 0, page_url_);
999   *success = true;
1000 }
1001 
OnSetCookie(const GURL & url,const GURL & first_party_for_cookies,const std::string & cookie)1002 void WebPluginDelegateProxy::OnSetCookie(const GURL& url,
1003                                          const GURL& first_party_for_cookies,
1004                                          const std::string& cookie) {
1005   if (plugin_)
1006     plugin_->SetCookie(url, first_party_for_cookies, cookie);
1007 }
1008 
OnGetCookies(const GURL & url,const GURL & first_party_for_cookies,std::string * cookies)1009 void WebPluginDelegateProxy::OnGetCookies(const GURL& url,
1010                                           const GURL& first_party_for_cookies,
1011                                           std::string* cookies) {
1012   DCHECK(cookies);
1013   if (plugin_)
1014     *cookies = plugin_->GetCookies(url, first_party_for_cookies);
1015 }
1016 
CopyFromBackBufferToFrontBuffer(const gfx::Rect & rect)1017 void WebPluginDelegateProxy::CopyFromBackBufferToFrontBuffer(
1018     const gfx::Rect& rect) {
1019 #if defined(OS_MACOSX)
1020   // Blitting the bits directly is much faster than going through CG, and since
1021   // the goal is just to move the raw pixels between two bitmaps with the same
1022   // pixel format (no compositing, color correction, etc.), it's safe.
1023   const size_t stride =
1024       skia::PlatformCanvasStrideForWidth(plugin_rect_.width());
1025   const size_t chunk_size = 4 * rect.width();
1026   DCHECK(back_buffer_dib() != NULL);
1027   uint8* source_data = static_cast<uint8*>(back_buffer_dib()->memory()) +
1028                        rect.y() * stride + 4 * rect.x();
1029   DCHECK(front_buffer_dib() != NULL);
1030   uint8* target_data = static_cast<uint8*>(front_buffer_dib()->memory()) +
1031                        rect.y() * stride + 4 * rect.x();
1032   for (int row = 0; row < rect.height(); ++row) {
1033     memcpy(target_data, source_data, chunk_size);
1034     source_data += stride;
1035     target_data += stride;
1036   }
1037 #else
1038   BlitCanvasToCanvas(front_buffer_canvas(),
1039                      rect,
1040                      back_buffer_canvas(),
1041                      rect.origin());
1042 #endif
1043 }
1044 
UpdateFrontBuffer(const gfx::Rect & rect,bool allow_buffer_flipping)1045 void WebPluginDelegateProxy::UpdateFrontBuffer(
1046     const gfx::Rect& rect,
1047     bool allow_buffer_flipping) {
1048   if (!front_buffer_canvas()) {
1049     return;
1050   }
1051 
1052 #if defined(OS_WIN)
1053   // If SendUpdateGeometry() would block on the plugin process then we don't
1054   // want to use buffer flipping at all since it would add extra locking.
1055   // (Alternatively we could probably safely use async updates for buffer
1056   // flipping all the time since the size is not changing.)
1057   if (UseSynchronousGeometryUpdates()) {
1058     allow_buffer_flipping = false;
1059   }
1060 #endif
1061 
1062   // Plugin has just painted "rect" into the back-buffer, so the front-buffer
1063   // no longer holds the latest content for that rectangle.
1064   front_buffer_diff_.Subtract(rect);
1065   if (allow_buffer_flipping && front_buffer_diff_.IsEmpty()) {
1066     // Back-buffer contains the latest content for all areas; simply flip
1067     // the buffers.
1068     front_buffer_index_ = back_buffer_index();
1069     SendUpdateGeometry(false);
1070     // The front-buffer now holds newer content for this region than the
1071     // back-buffer.
1072     front_buffer_diff_ = rect;
1073   } else {
1074     // Back-buffer contains the latest content for "rect" but the front-buffer
1075     // contains the latest content for some other areas (or buffer flipping not
1076     // allowed); fall back to copying the data.
1077     CopyFromBackBufferToFrontBuffer(rect);
1078   }
1079   transport_store_painted_.Union(rect);
1080 }
1081 
OnHandleURLRequest(const PluginHostMsg_URLRequest_Params & params)1082 void WebPluginDelegateProxy::OnHandleURLRequest(
1083     const PluginHostMsg_URLRequest_Params& params) {
1084   const char* data = NULL;
1085   if (params.buffer.size())
1086     data = &params.buffer[0];
1087 
1088   const char* target = NULL;
1089   if (params.target.length())
1090     target = params.target.c_str();
1091 
1092   plugin_->HandleURLRequest(
1093       params.url.c_str(), params.method.c_str(), target, data,
1094       static_cast<unsigned int>(params.buffer.size()), params.notify_id,
1095       params.popups_allowed, params.notify_redirects);
1096 }
1097 
CreateResourceClient(unsigned long resource_id,const GURL & url,int notify_id)1098 WebPluginResourceClient* WebPluginDelegateProxy::CreateResourceClient(
1099     unsigned long resource_id, const GURL& url, int notify_id) {
1100   if (!channel_host_.get())
1101     return NULL;
1102 
1103   ResourceClientProxy* proxy =
1104       new ResourceClientProxy(channel_host_.get(), instance_id_);
1105   proxy->Initialize(resource_id, url, notify_id);
1106   return proxy;
1107 }
1108 
CreateSeekableResourceClient(unsigned long resource_id,int range_request_id)1109 WebPluginResourceClient* WebPluginDelegateProxy::CreateSeekableResourceClient(
1110     unsigned long resource_id, int range_request_id) {
1111   if (!channel_host_.get())
1112     return NULL;
1113 
1114   ResourceClientProxy* proxy =
1115       new ResourceClientProxy(channel_host_.get(), instance_id_);
1116   proxy->InitializeForSeekableStream(resource_id, range_request_id);
1117   return proxy;
1118 }
1119 
FetchURL(unsigned long resource_id,int notify_id,const GURL & url,const GURL & first_party_for_cookies,const std::string & method,const char * buf,unsigned int len,const GURL & referrer,bool notify_redirects,bool is_plugin_src_load,int origin_pid,int render_frame_id,int render_view_id)1120 void WebPluginDelegateProxy::FetchURL(unsigned long resource_id,
1121                                       int notify_id,
1122                                       const GURL& url,
1123                                       const GURL& first_party_for_cookies,
1124                                       const std::string& method,
1125                                       const char* buf,
1126                                       unsigned int len,
1127                                       const GURL& referrer,
1128                                       bool notify_redirects,
1129                                       bool is_plugin_src_load,
1130                                       int origin_pid,
1131                                       int render_frame_id,
1132                                       int render_view_id) {
1133   PluginMsg_FetchURL_Params params;
1134   params.resource_id = resource_id;
1135   params.notify_id = notify_id;
1136   params.url = url;
1137   params.first_party_for_cookies = first_party_for_cookies;
1138   params.method = method;
1139   if (len) {
1140     params.post_data.resize(len);
1141     memcpy(&params.post_data.front(), buf, len);
1142   }
1143   params.referrer = referrer;
1144   params.notify_redirect = notify_redirects;
1145   params.is_plugin_src_load = is_plugin_src_load;
1146   params.render_frame_id = render_frame_id;
1147   Send(new PluginMsg_FetchURL(instance_id_, params));
1148 }
1149 
1150 #if defined(OS_MACOSX)
OnFocusChanged(bool focused)1151 void WebPluginDelegateProxy::OnFocusChanged(bool focused) {
1152   if (render_view_)
1153     render_view_->PluginFocusChanged(focused, instance_id_);
1154 }
1155 
OnStartIme()1156 void WebPluginDelegateProxy::OnStartIme() {
1157   if (render_view_)
1158     render_view_->StartPluginIme();
1159 }
1160 #endif
1161 
GetPluginWindowHandle()1162 gfx::PluginWindowHandle WebPluginDelegateProxy::GetPluginWindowHandle() {
1163   return window_;
1164 }
1165 
OnCancelDocumentLoad()1166 void WebPluginDelegateProxy::OnCancelDocumentLoad() {
1167   plugin_->CancelDocumentLoad();
1168 }
1169 
OnInitiateHTTPRangeRequest(const std::string & url,const std::string & range_info,int range_request_id)1170 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
1171     const std::string& url,
1172     const std::string& range_info,
1173     int range_request_id) {
1174   plugin_->InitiateHTTPRangeRequest(
1175       url.c_str(), range_info.c_str(), range_request_id);
1176 }
1177 
OnDidStartLoading()1178 void WebPluginDelegateProxy::OnDidStartLoading() {
1179   plugin_->DidStartLoading();
1180 }
1181 
OnDidStopLoading()1182 void WebPluginDelegateProxy::OnDidStopLoading() {
1183   plugin_->DidStopLoading();
1184 }
1185 
OnDeferResourceLoading(unsigned long resource_id,bool defer)1186 void WebPluginDelegateProxy::OnDeferResourceLoading(unsigned long resource_id,
1187                                                     bool defer) {
1188   plugin_->SetDeferResourceLoading(resource_id, defer);
1189 }
1190 
1191 #if defined(OS_MACOSX)
OnAcceleratedPluginEnabledRendering()1192 void WebPluginDelegateProxy::OnAcceleratedPluginEnabledRendering() {
1193   uses_compositor_ = true;
1194   OnSetWindow(gfx::kNullPluginWindow);
1195 }
1196 
OnAcceleratedPluginAllocatedIOSurface(int32 width,int32 height,uint32 surface_id)1197 void WebPluginDelegateProxy::OnAcceleratedPluginAllocatedIOSurface(
1198     int32 width,
1199     int32 height,
1200     uint32 surface_id) {
1201   if (plugin_)
1202     plugin_->AcceleratedPluginAllocatedIOSurface(width, height, surface_id);
1203 }
1204 
OnAcceleratedPluginSwappedIOSurface()1205 void WebPluginDelegateProxy::OnAcceleratedPluginSwappedIOSurface() {
1206   if (plugin_)
1207     plugin_->AcceleratedPluginSwappedIOSurface();
1208 }
1209 #endif
1210 
1211 #if defined(OS_WIN)
UseSynchronousGeometryUpdates()1212 bool WebPluginDelegateProxy::UseSynchronousGeometryUpdates() {
1213   // Need to update geometry synchronously with WMP, otherwise if a site
1214   // scripts the plugin to start playing while it's in the middle of handling
1215   // an update geometry message, videos don't play.  See urls in bug 20260.
1216   if (info_.name.find(base::ASCIIToUTF16("Windows Media Player")) !=
1217       base::string16::npos)
1218     return true;
1219 
1220   // The move networks plugin needs to be informed of geometry updates
1221   // synchronously.
1222   std::vector<WebPluginMimeType>::iterator index;
1223   for (index = info_.mime_types.begin(); index != info_.mime_types.end();
1224        index++) {
1225     if (index->mime_type == "application/x-vnd.moveplayer.qm" ||
1226         index->mime_type == "application/x-vnd.moveplay2.qm" ||
1227         index->mime_type == "application/x-vnd.movenetworks.qm" ||
1228         index->mime_type == "application/x-vnd.mnplayer.qm") {
1229       return true;
1230     }
1231   }
1232   return false;
1233 }
1234 #endif
1235 
OnURLRedirectResponse(bool allow,int resource_id)1236 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
1237                                                    int resource_id) {
1238   if (!plugin_)
1239     return;
1240 
1241   plugin_->URLRedirectResponse(allow, resource_id);
1242 }
1243 
OnCheckIfRunInsecureContent(const GURL & url,bool * result)1244 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
1245                                                          bool* result) {
1246   *result = plugin_->CheckIfRunInsecureContent(url);
1247 }
1248 
1249 }  // namespace content
1250