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