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