webplugin_delegate_proxy.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7
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#if defined(TOOLKIT_GTK) 8#include <gtk/gtk.h> 9#elif defined(USE_X11) 10#include <cairo/cairo.h> 11#endif 12 13#include <algorithm> 14 15#include "base/auto_reset.h" 16#include "base/basictypes.h" 17#include "base/command_line.h" 18#include "base/file_util.h" 19#include "base/logging.h" 20#include "base/memory/ref_counted.h" 21#include "base/memory/scoped_ptr.h" 22#include "base/process/process.h" 23#include "base/strings/string_split.h" 24#include "base/strings/string_util.h" 25#include "base/strings/utf_string_conversions.h" 26#include "base/version.h" 27#include "content/child/child_process.h" 28#include "content/child/npapi/npobject_proxy.h" 29#include "content/child/npapi/npobject_stub.h" 30#include "content/child/npapi/npobject_util.h" 31#include "content/child/npapi/webplugin_resource_client.h" 32#include "content/child/plugin_messages.h" 33#include "content/common/content_constants_internal.h" 34#include "content/common/frame_messages.h" 35#include "content/common/view_messages.h" 36#include "content/public/renderer/content_renderer_client.h" 37#include "content/renderer/npapi/plugin_channel_host.h" 38#include "content/renderer/npapi/webplugin_impl.h" 39#include "content/renderer/render_thread_impl.h" 40#include "content/renderer/render_view_impl.h" 41#include "content/renderer/sad_plugin.h" 42#include "ipc/ipc_channel_handle.h" 43#include "net/base/mime_util.h" 44#include "skia/ext/platform_canvas.h" 45#include "third_party/WebKit/public/web/WebBindings.h" 46#include "third_party/WebKit/public/web/WebDocument.h" 47#include "third_party/WebKit/public/web/WebFrame.h" 48#include "third_party/WebKit/public/web/WebView.h" 49#include "third_party/WebKit/public/platform/WebDragData.h" 50#include "third_party/WebKit/public/platform/WebString.h" 51#include "ui/gfx/blit.h" 52#include "ui/gfx/canvas.h" 53#include "ui/gfx/native_widget_types.h" 54#include "ui/gfx/size.h" 55#include "ui/gfx/skia_util.h" 56#include "webkit/common/cursors/webcursor.h" 57 58#if defined(OS_POSIX) 59#include "ipc/ipc_channel_posix.h" 60#endif 61 62#if defined(OS_MACOSX) 63#include "base/mac/mac_util.h" 64#endif 65 66#if defined(OS_WIN) 67#include "content/public/common/sandbox_init.h" 68#endif 69 70using blink::WebBindings; 71using blink::WebCursorInfo; 72using blink::WebDragData; 73using blink::WebInputEvent; 74using blink::WebString; 75using blink::WebView; 76 77namespace content { 78 79namespace { 80 81class ScopedLogLevel { 82 public: 83 explicit ScopedLogLevel(int level); 84 ~ScopedLogLevel(); 85 86 private: 87 int old_level_; 88 89 DISALLOW_COPY_AND_ASSIGN(ScopedLogLevel); 90}; 91 92ScopedLogLevel::ScopedLogLevel(int level) 93 : old_level_(logging::GetMinLogLevel()) { 94 logging::SetMinLogLevel(level); 95} 96 97ScopedLogLevel::~ScopedLogLevel() { 98 logging::SetMinLogLevel(old_level_); 99} 100 101// Proxy for WebPluginResourceClient. The object owns itself after creation, 102// deleting itself after its callback has been called. 103class ResourceClientProxy : public WebPluginResourceClient { 104 public: 105 ResourceClientProxy(PluginChannelHost* channel, int instance_id) 106 : channel_(channel), instance_id_(instance_id), resource_id_(0), 107 multibyte_response_expected_(false) { 108 } 109 110 virtual ~ResourceClientProxy() { 111 } 112 113 void Initialize(unsigned long resource_id, const GURL& url, int notify_id) { 114 resource_id_ = resource_id; 115 channel_->Send(new PluginMsg_HandleURLRequestReply( 116 instance_id_, resource_id, url, notify_id)); 117 } 118 119 void InitializeForSeekableStream(unsigned long resource_id, 120 int range_request_id) { 121 resource_id_ = resource_id; 122 multibyte_response_expected_ = true; 123 channel_->Send(new PluginMsg_HTTPRangeRequestReply( 124 instance_id_, resource_id, range_request_id)); 125 } 126 127 // PluginResourceClient implementation: 128 virtual void WillSendRequest(const GURL& url, int http_status_code) OVERRIDE { 129 DCHECK(channel_.get() != NULL); 130 channel_->Send(new PluginMsg_WillSendRequest( 131 instance_id_, resource_id_, url, http_status_code)); 132 } 133 134 virtual void DidReceiveResponse(const std::string& mime_type, 135 const std::string& headers, 136 uint32 expected_length, 137 uint32 last_modified, 138 bool request_is_seekable) OVERRIDE { 139 DCHECK(channel_.get() != NULL); 140 PluginMsg_DidReceiveResponseParams params; 141 params.id = resource_id_; 142 params.mime_type = mime_type; 143 params.headers = headers; 144 params.expected_length = expected_length; 145 params.last_modified = last_modified; 146 params.request_is_seekable = request_is_seekable; 147 // Grab a reference on the underlying channel so it does not get 148 // deleted from under us. 149 scoped_refptr<PluginChannelHost> channel_ref(channel_); 150 channel_->Send(new PluginMsg_DidReceiveResponse(instance_id_, params)); 151 } 152 153 virtual void DidReceiveData(const char* buffer, 154 int length, 155 int data_offset) OVERRIDE { 156 DCHECK(channel_.get() != NULL); 157 DCHECK_GT(length, 0); 158 std::vector<char> data; 159 data.resize(static_cast<size_t>(length)); 160 memcpy(&data.front(), buffer, length); 161 // Grab a reference on the underlying channel so it does not get 162 // deleted from under us. 163 scoped_refptr<PluginChannelHost> channel_ref(channel_); 164 channel_->Send(new PluginMsg_DidReceiveData(instance_id_, resource_id_, 165 data, data_offset)); 166 } 167 168 virtual void DidFinishLoading(unsigned long resource_id) OVERRIDE { 169 DCHECK(channel_.get() != NULL); 170 DCHECK_EQ(resource_id, resource_id_); 171 channel_->Send(new PluginMsg_DidFinishLoading(instance_id_, resource_id_)); 172 channel_ = NULL; 173 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this); 174 } 175 176 virtual void DidFail(unsigned long resource_id) OVERRIDE { 177 DCHECK(channel_.get() != NULL); 178 DCHECK_EQ(resource_id, resource_id_); 179 channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_)); 180 channel_ = NULL; 181 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this); 182 } 183 184 virtual bool IsMultiByteResponseExpected() OVERRIDE { 185 return multibyte_response_expected_; 186 } 187 188 virtual int ResourceId() OVERRIDE { 189 return resource_id_; 190 } 191 192 private: 193 scoped_refptr<PluginChannelHost> channel_; 194 int instance_id_; 195 unsigned long resource_id_; 196 // Set to true if the response expected is a multibyte response. 197 // For e.g. response for a HTTP byte range request. 198 bool multibyte_response_expected_; 199}; 200 201} // namespace 202 203WebPluginDelegateProxy::WebPluginDelegateProxy( 204 WebPluginImpl* plugin, 205 const std::string& mime_type, 206 const base::WeakPtr<RenderViewImpl>& render_view, 207 RenderFrameImpl* render_frame) 208 : render_view_(render_view), 209 render_frame_(render_frame), 210 plugin_(plugin), 211 uses_shared_bitmaps_(false), 212#if defined(OS_MACOSX) 213 uses_compositor_(false), 214#elif defined(OS_WIN) 215 dummy_activation_window_(NULL), 216#endif 217 window_(gfx::kNullPluginWindow), 218 mime_type_(mime_type), 219 instance_id_(MSG_ROUTING_NONE), 220 npobject_(NULL), 221 npp_(new NPP_t), 222 sad_plugin_(NULL), 223 invalidate_pending_(false), 224 transparent_(false), 225 front_buffer_index_(0), 226 page_url_(render_view_->webview()->mainFrame()->document().url()) { 227} 228 229WebPluginDelegateProxy::~WebPluginDelegateProxy() { 230 if (npobject_) 231 WebBindings::releaseObject(npobject_); 232} 233 234WebPluginDelegateProxy::SharedBitmap::SharedBitmap() {} 235 236WebPluginDelegateProxy::SharedBitmap::~SharedBitmap() {} 237 238void WebPluginDelegateProxy::PluginDestroyed() { 239#if defined(OS_MACOSX) || defined(OS_WIN) 240 // Ensure that the renderer doesn't think the plugin still has focus. 241 if (render_view_) 242 render_view_->PluginFocusChanged(false, instance_id_); 243#endif 244 245#if defined(OS_WIN) 246 if (dummy_activation_window_ && render_view_) { 247 render_view_->Send(new ViewHostMsg_WindowlessPluginDummyWindowDestroyed( 248 render_view_->routing_id(), dummy_activation_window_)); 249 } 250 dummy_activation_window_ = NULL; 251#endif 252 253 if (window_) 254 WillDestroyWindow(); 255 256 if (render_view_.get()) 257 render_view_->UnregisterPluginDelegate(this); 258 259 if (channel_host_.get()) { 260 Send(new PluginMsg_DestroyInstance(instance_id_)); 261 262 // Must remove the route after sending the destroy message, rather than 263 // before, since RemoveRoute can lead to all the outstanding NPObjects 264 // being told the channel went away if this was the last instance. 265 channel_host_->RemoveRoute(instance_id_); 266 267 // Remove the mapping between our instance-Id and NPP identifiers, used by 268 // the channel to track object ownership, before releasing it. 269 channel_host_->RemoveMappingForNPObjectOwner(instance_id_); 270 271 // Release the channel host now. If we are is the last reference to the 272 // channel, this avoids a race where this renderer asks a new connection to 273 // the same plugin between now and the time 'this' is actually deleted. 274 // Destroying the channel host is what releases the channel name -> FD 275 // association on POSIX, and if we ask for a new connection before it is 276 // released, the plugin will give us a new FD, and we'll assert when trying 277 // to associate it with the channel name. 278 channel_host_ = NULL; 279 } 280 281 plugin_ = NULL; 282 283 base::MessageLoop::current()->DeleteSoon(FROM_HERE, this); 284} 285 286bool WebPluginDelegateProxy::Initialize( 287 const GURL& url, 288 const std::vector<std::string>& arg_names, 289 const std::vector<std::string>& arg_values, 290 bool load_manually) { 291 // TODO(shess): Attempt to work around http://crbug.com/97285 and 292 // http://crbug.com/141055 by retrying the connection. Reports seem 293 // to indicate that the plugin hasn't crashed, and that the problem 294 // is not 100% persistent. 295 const size_t kAttempts = 2; 296 297 bool result = false; 298 scoped_refptr<PluginChannelHost> channel_host; 299 int instance_id = 0; 300 301 for (size_t attempt = 0; !result && attempt < kAttempts; attempt++) { 302#if defined(OS_MACOSX) 303 // TODO(shess): Debugging for http://crbug.com/97285 . See comment 304 // in plugin_channel_host.cc. 305 scoped_ptr<base::AutoReset<bool> > track_nested_removes( 306 new base::AutoReset<bool>(PluginChannelHost::GetRemoveTrackingFlag(), 307 true)); 308#endif 309 310 IPC::ChannelHandle channel_handle; 311 if (!RenderThreadImpl::current()->Send(new FrameHostMsg_OpenChannelToPlugin( 312 render_frame_->GetRoutingID(), url, page_url_, mime_type_, 313 &channel_handle, &info_))) { 314 continue; 315 } 316 317 if (channel_handle.name.empty()) { 318 // We got an invalid handle. Either the plugin couldn't be found (which 319 // shouldn't happen, since if we got here the plugin should exist) or the 320 // plugin crashed on initialization. 321 if (!info_.path.empty()) { 322 render_view_->main_render_frame()->PluginCrashed( 323 info_.path, base::kNullProcessId); 324 LOG(ERROR) << "Plug-in crashed on start"; 325 326 // Return true so that the plugin widget is created and we can paint the 327 // crashed plugin there. 328 return true; 329 } 330 LOG(ERROR) << "Plug-in couldn't be found"; 331 return false; 332 } 333 334 channel_host = 335 PluginChannelHost::GetPluginChannelHost( 336 channel_handle, ChildProcess::current()->io_message_loop_proxy()); 337 if (!channel_host.get()) { 338 LOG(ERROR) << "Couldn't get PluginChannelHost"; 339 continue; 340 } 341#if defined(OS_MACOSX) 342 track_nested_removes.reset(); 343#endif 344 345 { 346 // TODO(bauerb): Debugging for http://crbug.com/141055. 347 ScopedLogLevel log_level(-2); // Equivalent to --v=2 348 result = channel_host->Send(new PluginMsg_CreateInstance( 349 mime_type_, &instance_id)); 350 if (!result) { 351 LOG(ERROR) << "Couldn't send PluginMsg_CreateInstance"; 352 continue; 353 } 354 } 355 } 356 357 // Failed too often, give up. 358 if (!result) 359 return false; 360 361 channel_host_ = channel_host; 362 instance_id_ = instance_id; 363 364 channel_host_->AddRoute(instance_id_, this, NULL); 365 366 // Inform the channel of the mapping between our instance-Id and dummy NPP 367 // identifier, for use in object ownership tracking. 368 channel_host_->AddMappingForNPObjectOwner(instance_id_, GetPluginNPP()); 369 370 // Now tell the PluginInstance in the plugin process to initialize. 371 PluginMsg_Init_Params params; 372 params.url = url; 373 params.page_url = page_url_; 374 params.arg_names = arg_names; 375 params.arg_values = arg_values; 376 params.host_render_view_routing_id = render_view_->routing_id(); 377 params.load_manually = load_manually; 378 379 result = false; 380 Send(new PluginMsg_Init(instance_id_, params, &transparent_, &result)); 381 382 if (!result) 383 LOG(WARNING) << "PluginMsg_Init returned false"; 384 385 render_view_->RegisterPluginDelegate(this); 386 387 return result; 388} 389 390bool WebPluginDelegateProxy::Send(IPC::Message* msg) { 391 if (!channel_host_.get()) { 392 DLOG(WARNING) << "dropping message because channel host is null"; 393 delete msg; 394 return false; 395 } 396 397 return channel_host_->Send(msg); 398} 399 400void WebPluginDelegateProxy::SendJavaScriptStream(const GURL& url, 401 const std::string& result, 402 bool success, 403 int notify_id) { 404 Send(new PluginMsg_SendJavaScriptStream( 405 instance_id_, url, result, success, notify_id)); 406} 407 408void WebPluginDelegateProxy::DidReceiveManualResponse( 409 const GURL& url, const std::string& mime_type, 410 const std::string& headers, uint32 expected_length, 411 uint32 last_modified) { 412 PluginMsg_DidReceiveResponseParams params; 413 params.id = 0; 414 params.mime_type = mime_type; 415 params.headers = headers; 416 params.expected_length = expected_length; 417 params.last_modified = last_modified; 418 Send(new PluginMsg_DidReceiveManualResponse(instance_id_, url, params)); 419} 420 421void WebPluginDelegateProxy::DidReceiveManualData(const char* buffer, 422 int length) { 423 DCHECK_GT(length, 0); 424 std::vector<char> data; 425 data.resize(static_cast<size_t>(length)); 426 memcpy(&data.front(), buffer, length); 427 Send(new PluginMsg_DidReceiveManualData(instance_id_, data)); 428} 429 430void WebPluginDelegateProxy::DidFinishManualLoading() { 431 Send(new PluginMsg_DidFinishManualLoading(instance_id_)); 432} 433 434void WebPluginDelegateProxy::DidManualLoadFail() { 435 Send(new PluginMsg_DidManualLoadFail(instance_id_)); 436} 437 438bool WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) { 439 GetContentClient()->SetActiveURL(page_url_); 440 441 bool handled = true; 442 IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg) 443 IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow) 444 IPC_MESSAGE_HANDLER(PluginHostMsg_CancelResource, OnCancelResource) 445 IPC_MESSAGE_HANDLER(PluginHostMsg_InvalidateRect, OnInvalidateRect) 446 IPC_MESSAGE_HANDLER(PluginHostMsg_GetWindowScriptNPObject, 447 OnGetWindowScriptNPObject) 448 IPC_MESSAGE_HANDLER(PluginHostMsg_GetPluginElement, OnGetPluginElement) 449 IPC_MESSAGE_HANDLER(PluginHostMsg_ResolveProxy, OnResolveProxy) 450 IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie) 451 IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies) 452 IPC_MESSAGE_HANDLER(PluginHostMsg_URLRequest, OnHandleURLRequest) 453 IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad) 454 IPC_MESSAGE_HANDLER(PluginHostMsg_InitiateHTTPRangeRequest, 455 OnInitiateHTTPRangeRequest) 456 IPC_MESSAGE_HANDLER(PluginHostMsg_DidStartLoading, OnDidStartLoading) 457 IPC_MESSAGE_HANDLER(PluginHostMsg_DidStopLoading, OnDidStopLoading) 458 IPC_MESSAGE_HANDLER(PluginHostMsg_DeferResourceLoading, 459 OnDeferResourceLoading) 460 IPC_MESSAGE_HANDLER(PluginHostMsg_URLRedirectResponse, 461 OnURLRedirectResponse) 462 IPC_MESSAGE_HANDLER(PluginHostMsg_CheckIfRunInsecureContent, 463 OnCheckIfRunInsecureContent) 464#if defined(OS_WIN) 465 IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessData, OnSetWindowlessData) 466 IPC_MESSAGE_HANDLER(PluginHostMsg_NotifyIMEStatus, OnNotifyIMEStatus) 467#endif 468#if defined(OS_MACOSX) 469 IPC_MESSAGE_HANDLER(PluginHostMsg_FocusChanged, 470 OnFocusChanged); 471 IPC_MESSAGE_HANDLER(PluginHostMsg_StartIme, 472 OnStartIme); 473 IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginEnabledRendering, 474 OnAcceleratedPluginEnabledRendering) 475 IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginAllocatedIOSurface, 476 OnAcceleratedPluginAllocatedIOSurface) 477 IPC_MESSAGE_HANDLER(PluginHostMsg_AcceleratedPluginSwappedIOSurface, 478 OnAcceleratedPluginSwappedIOSurface) 479#endif 480 IPC_MESSAGE_UNHANDLED(handled = false) 481 IPC_END_MESSAGE_MAP() 482 DCHECK(handled); 483 return handled; 484} 485 486void WebPluginDelegateProxy::OnChannelError() { 487 if (plugin_) { 488 if (window_) { 489 // The actual WebPluginDelegate never got a chance to tell the WebPlugin 490 // its window was going away. Do it on its behalf. 491 WillDestroyWindow(); 492 } 493 plugin_->Invalidate(); 494 } 495 if (!channel_host_->expecting_shutdown()) { 496 render_view_->main_render_frame()->PluginCrashed( 497 info_.path, channel_host_->peer_pid()); 498 } 499 500#if defined(OS_MACOSX) || defined(OS_WIN) 501 // Ensure that the renderer doesn't think the plugin still has focus. 502 if (render_view_) 503 render_view_->PluginFocusChanged(false, instance_id_); 504#endif 505} 506 507static void CopyTransportDIBHandleForMessage( 508 const TransportDIB::Handle& handle_in, 509 TransportDIB::Handle* handle_out, 510 base::ProcessId peer_pid) { 511#if defined(OS_MACOSX) 512 // On Mac, TransportDIB::Handle is typedef'ed to FileDescriptor, and 513 // FileDescriptor message fields needs to remain valid until the message is 514 // sent or else the sendmsg() call will fail. 515 if ((handle_out->fd = HANDLE_EINTR(dup(handle_in.fd))) < 0) { 516 PLOG(ERROR) << "dup()"; 517 return; 518 } 519 handle_out->auto_close = true; 520#elif defined(OS_WIN) 521 // On Windows we need to duplicate the handle for the plugin process. 522 *handle_out = NULL; 523 BrokerDuplicateHandle(handle_in, peer_pid, handle_out, 524 FILE_MAP_READ | FILE_MAP_WRITE, 0); 525 DCHECK(*handle_out != NULL); 526#else 527 // Don't need to do anything special for other platforms. 528 *handle_out = handle_in; 529#endif 530} 531 532void WebPluginDelegateProxy::SendUpdateGeometry( 533 bool bitmaps_changed) { 534 PluginMsg_UpdateGeometry_Param param; 535 param.window_rect = plugin_rect_; 536 param.clip_rect = clip_rect_; 537 param.windowless_buffer0 = TransportDIB::DefaultHandleValue(); 538 param.windowless_buffer1 = TransportDIB::DefaultHandleValue(); 539 param.windowless_buffer_index = back_buffer_index(); 540 541#if defined(OS_POSIX) 542 // If we're using POSIX mmap'd TransportDIBs, sending the handle across 543 // IPC establishes a new mapping rather than just sending a window ID, 544 // so only do so if we've actually changed the shared memory bitmaps. 545 if (bitmaps_changed) 546#endif 547 { 548 if (transport_stores_[0].dib) 549 CopyTransportDIBHandleForMessage(transport_stores_[0].dib->handle(), 550 ¶m.windowless_buffer0, 551 channel_host_->peer_pid()); 552 553 if (transport_stores_[1].dib) 554 CopyTransportDIBHandleForMessage(transport_stores_[1].dib->handle(), 555 ¶m.windowless_buffer1, 556 channel_host_->peer_pid()); 557 } 558 559 IPC::Message* msg; 560#if defined(OS_WIN) 561 if (UseSynchronousGeometryUpdates()) { 562 msg = new PluginMsg_UpdateGeometrySync(instance_id_, param); 563 } else // NOLINT 564#endif 565 { 566 msg = new PluginMsg_UpdateGeometry(instance_id_, param); 567 msg->set_unblock(true); 568 } 569 570 Send(msg); 571} 572 573void WebPluginDelegateProxy::UpdateGeometry(const gfx::Rect& window_rect, 574 const gfx::Rect& clip_rect) { 575 // window_rect becomes either a window in native windowing system 576 // coords, or a backing buffer. In either case things will go bad 577 // if the rectangle is very large. 578 if (window_rect.width() < 0 || window_rect.width() > kMaxPluginSideLength || 579 window_rect.height() < 0 || window_rect.height() > kMaxPluginSideLength || 580 // We know this won't overflow due to above checks. 581 static_cast<uint32>(window_rect.width()) * 582 static_cast<uint32>(window_rect.height()) > kMaxPluginSize) { 583 return; 584 } 585 586 plugin_rect_ = window_rect; 587 clip_rect_ = clip_rect; 588 589 bool bitmaps_changed = false; 590 591 if (uses_shared_bitmaps_) { 592 if (!front_buffer_canvas() || 593 (window_rect.width() != front_buffer_canvas()->getDevice()->width() || 594 window_rect.height() != front_buffer_canvas()->getDevice()->height())) 595 { 596 bitmaps_changed = true; 597 598 // Create a shared memory section that the plugin paints into 599 // asynchronously. 600 ResetWindowlessBitmaps(); 601 if (!window_rect.IsEmpty()) { 602 if (!CreateSharedBitmap(&transport_stores_[0].dib, 603 &transport_stores_[0].canvas) || 604 !CreateSharedBitmap(&transport_stores_[1].dib, 605 &transport_stores_[1].canvas)) { 606 DCHECK(false); 607 ResetWindowlessBitmaps(); 608 return; 609 } 610 } 611 } 612 } 613 614 SendUpdateGeometry(bitmaps_changed); 615} 616 617void WebPluginDelegateProxy::ResetWindowlessBitmaps() { 618 transport_stores_[0].dib.reset(); 619 transport_stores_[1].dib.reset(); 620 621 transport_stores_[0].canvas.reset(); 622 transport_stores_[1].canvas.reset(); 623 transport_store_painted_ = gfx::Rect(); 624 front_buffer_diff_ = gfx::Rect(); 625} 626 627static size_t BitmapSizeForPluginRect(const gfx::Rect& plugin_rect) { 628 const size_t stride = 629 skia::PlatformCanvasStrideForWidth(plugin_rect.width()); 630 return stride * plugin_rect.height(); 631} 632 633#if !defined(OS_WIN) 634bool WebPluginDelegateProxy::CreateLocalBitmap( 635 std::vector<uint8>* memory, 636 scoped_ptr<skia::PlatformCanvas>* canvas) { 637 const size_t size = BitmapSizeForPluginRect(plugin_rect_); 638 memory->resize(size); 639 if (memory->size() != size) 640 return false; 641 canvas->reset(skia::CreatePlatformCanvas( 642 plugin_rect_.width(), plugin_rect_.height(), true, &((*memory)[0]), 643 skia::CRASH_ON_FAILURE)); 644 return true; 645} 646#endif 647 648bool WebPluginDelegateProxy::CreateSharedBitmap( 649 scoped_ptr<TransportDIB>* memory, 650 scoped_ptr<skia::PlatformCanvas>* canvas) { 651 const size_t size = BitmapSizeForPluginRect(plugin_rect_); 652#if defined(OS_POSIX) && !defined(OS_MACOSX) 653 memory->reset(TransportDIB::Create(size, 0)); 654 if (!memory->get()) 655 return false; 656#endif 657#if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID) 658 TransportDIB::Handle handle; 659 IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(size, false, &handle); 660 if (!RenderThreadImpl::current()->Send(msg)) 661 return false; 662 if (handle.fd < 0) 663 return false; 664 memory->reset(TransportDIB::Map(handle)); 665#else 666 static uint32 sequence_number = 0; 667 memory->reset(TransportDIB::Create(size, sequence_number++)); 668#endif 669 canvas->reset((*memory)->GetPlatformCanvas(plugin_rect_.width(), 670 plugin_rect_.height())); 671 return !!canvas->get(); 672} 673 674void WebPluginDelegateProxy::Paint(SkCanvas* canvas, 675 const gfx::Rect& damaged_rect) { 676 // Limit the damaged rectangle to whatever is contained inside the plugin 677 // rectangle, as that's the rectangle that we'll actually draw. 678 gfx::Rect rect = gfx::IntersectRects(damaged_rect, plugin_rect_); 679 680 // If the plugin is no longer connected (channel crashed) draw a crashed 681 // plugin bitmap 682 if (!channel_host_.get() || !channel_host_->channel_valid()) { 683 // Lazily load the sad plugin image. 684 if (!sad_plugin_) 685 sad_plugin_ = GetContentClient()->renderer()->GetSadPluginBitmap(); 686 if (sad_plugin_) 687 PaintSadPlugin(canvas, plugin_rect_, *sad_plugin_); 688 return; 689 } 690 691 if (!uses_shared_bitmaps_) 692 return; 693 694 // We got a paint before the plugin's coordinates, so there's no buffer to 695 // copy from. 696 if (!front_buffer_canvas()) 697 return; 698 699 gfx::Rect offset_rect = rect; 700 offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y()); 701 702 // transport_store_painted_ is really a bounding box, so in principle this 703 // check could falsely indicate that we don't need to paint offset_rect, but 704 // in practice it works fine. 705 if (!transport_store_painted_.Contains(offset_rect)) { 706 Send(new PluginMsg_Paint(instance_id_, offset_rect)); 707 // Since the plugin is not blocked on the renderer in this context, there is 708 // a chance that it will begin repainting the back-buffer before we complete 709 // capturing the data. Buffer flipping would increase that risk because 710 // geometry update is asynchronous, so we don't want to use buffer flipping 711 // here. 712 UpdateFrontBuffer(offset_rect, false); 713 } 714 715 const SkBitmap& bitmap = 716 front_buffer_canvas()->getDevice()->accessBitmap(false); 717 SkPaint paint; 718 paint.setXfermodeMode( 719 transparent_ ? SkXfermode::kSrcATop_Mode : SkXfermode::kSrc_Mode); 720 SkIRect src_rect = gfx::RectToSkIRect(offset_rect); 721 canvas->drawBitmapRect(bitmap, 722 &src_rect, 723 gfx::RectToSkRect(rect), 724 &paint); 725 726 if (invalidate_pending_) { 727 // Only send the PaintAck message if this paint is in response to an 728 // invalidate from the plugin, since this message acts as an access token 729 // to ensure only one process is using the transport dib at a time. 730 invalidate_pending_ = false; 731 Send(new PluginMsg_DidPaint(instance_id_)); 732 } 733} 734 735NPObject* WebPluginDelegateProxy::GetPluginScriptableObject() { 736 if (npobject_) 737 return WebBindings::retainObject(npobject_); 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; 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 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 943void WebPluginDelegateProxy::OnCancelResource(int id) { 944 if (plugin_) 945 plugin_->CancelResource(id); 946} 947 948void 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 965void 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 981void WebPluginDelegateProxy::OnResolveProxy(const GURL& url, 982 bool* result, 983 std::string* proxy_list) { 984 *result = RenderThreadImpl::current()->ResolveProxy(url, proxy_list); 985} 986 987void 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 1002void 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 1009void 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 1017void 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 1045void 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 1082void WebPluginDelegateProxy::OnHandleURLRequest( 1083 const PluginHostMsg_URLRequest_Params& params) { 1084 const char* data = NULL; 1085 if (params.buffer.size()) 1086 data = ¶ms.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 1098WebPluginResourceClient* 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 1109WebPluginResourceClient* 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 1120void 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(¶ms.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) 1151void WebPluginDelegateProxy::OnFocusChanged(bool focused) { 1152 if (render_view_) 1153 render_view_->PluginFocusChanged(focused, instance_id_); 1154} 1155 1156void WebPluginDelegateProxy::OnStartIme() { 1157 if (render_view_) 1158 render_view_->StartPluginIme(); 1159} 1160#endif 1161 1162gfx::PluginWindowHandle WebPluginDelegateProxy::GetPluginWindowHandle() { 1163 return window_; 1164} 1165 1166void WebPluginDelegateProxy::OnCancelDocumentLoad() { 1167 plugin_->CancelDocumentLoad(); 1168} 1169 1170void 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 1178void WebPluginDelegateProxy::OnDidStartLoading() { 1179 plugin_->DidStartLoading(); 1180} 1181 1182void WebPluginDelegateProxy::OnDidStopLoading() { 1183 plugin_->DidStopLoading(); 1184} 1185 1186void WebPluginDelegateProxy::OnDeferResourceLoading(unsigned long resource_id, 1187 bool defer) { 1188 plugin_->SetDeferResourceLoading(resource_id, defer); 1189} 1190 1191#if defined(OS_MACOSX) 1192void WebPluginDelegateProxy::OnAcceleratedPluginEnabledRendering() { 1193 uses_compositor_ = true; 1194 OnSetWindow(gfx::kNullPluginWindow); 1195} 1196 1197void WebPluginDelegateProxy::OnAcceleratedPluginAllocatedIOSurface( 1198 int32 width, 1199 int32 height, 1200 uint32 surface_id) { 1201 if (plugin_) 1202 plugin_->AcceleratedPluginAllocatedIOSurface(width, height, surface_id); 1203} 1204 1205void WebPluginDelegateProxy::OnAcceleratedPluginSwappedIOSurface() { 1206 if (plugin_) 1207 plugin_->AcceleratedPluginSwappedIOSurface(); 1208} 1209#endif 1210 1211#if defined(OS_WIN) 1212bool 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 1236void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow, 1237 int resource_id) { 1238 if (!plugin_) 1239 return; 1240 1241 plugin_->URLRedirectResponse(allow, resource_id); 1242} 1243 1244void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url, 1245 bool* result) { 1246 *result = plugin_->CheckIfRunInsecureContent(url); 1247} 1248 1249} // namespace content 1250