Implemented Browser Plugin (NOT FOR REVIEW)

content/renderer/render_view_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 37 matching lines @@
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_view_observer.h"
 #include "content/public/renderer/render_view_visitor.h"
 #include "content/renderer/device_orientation_dispatcher.h"
 #include "content/renderer/devtools_agent.h"
 #include "content/renderer/dom_automation_controller.h"
 #include "content/renderer/external_popup_menu.h"
 #include "content/renderer/geolocation_dispatcher.h"
+#include "content/renderer/guest_render_view_observer.h"
 #include "content/renderer/idle_user_detector.h"
 #include "content/renderer/input_tag_speech_dispatcher.h"
 #include "content/renderer/web_intents_host.h"
 #include "content/renderer/java/java_bridge_dispatcher.h"
 #include "content/renderer/load_progress_tracker.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/audio_renderer_impl.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_impl.h"
 #include "content/renderer/media/render_audiosourceprovider.h"
 #include "content/renderer/media/render_media_log.h"
 #include "content/renderer/media/renderer_gpu_video_decoder_factories.h"
 #include "content/renderer/mhtml_generator.h"
 #include "content/renderer/mouse_lock_dispatcher.h"
 #include "content/renderer/notification_provider.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "content/renderer/plugin_channel_host.h"
+#include "content/renderer/plugins/browser_plugin_placeholder.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_widget_fullscreen_pepper.h"
 #include "content/renderer/renderer_accessibility.h"
 #include "content/renderer/renderer_webapplicationcachehost_impl.h"
 #include "content/renderer/renderer_webstoragenamespace_impl.h"
 #include "content/renderer/text_input_client_observer.h"
 #include "content/renderer/v8_value_converter_impl.h"
 #include "content/renderer/web_ui_bindings.h"
 #include "content/renderer/webplugin_delegate_proxy.h"
@@ skipping 72 matching lines @@
 #include "webkit/glue/webdropdata.h"
 #include "webkit/glue/webkit_constants.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/weburlloader_impl.h"
 #include "webkit/glue/weburlresponse_extradata_impl.h"
 #include "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 #include "webkit/media/webmediaplayer_impl.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/webplugin_delegate.h"
 #include "webkit/plugins/npapi/webplugin_delegate_impl.h"
+#include "webkit/plugins/plugin_constants.h"
 #include "webkit/plugins/npapi/webplugin_impl.h"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 
 #if defined(OS_WIN)
 // TODO(port): these files are currently Windows only because they concern:
 //   * theming
 #include "ui/gfx/native_theme_win.h"
 #elif defined(USE_X11)
 #include "third_party/WebKit/Source/WebKit/chromium/public/linux/WebRenderTheme.h"
 #include "ui/gfx/native_theme.h"
@@ skipping 234 matching lines @@
     gfx::NativeViewId parent_hwnd,
     int32 opener_id,
     const content::RendererPreferences& renderer_prefs,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id,
     int32 surface_id,
     int64 session_storage_namespace_id,
     const string16& frame_name,
     int32 next_page_id,
-    const WebKit::WebScreenInfo& screen_info)
+    const WebKit::WebScreenInfo& screen_info,
+    bool guest)
     : RenderWidget(WebKit::WebPopupTypeNone, screen_info),
       webkit_preferences_(webkit_prefs),
       send_content_state_immediately_(false),
       enabled_bindings_(0),
       send_preferred_size_changes_(false),
       is_loading_(false),
       navigation_gesture_(NavigationGestureUnknown),
       opened_by_user_gesture_(true),
       opener_suppressed_(false),
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
       next_page_id_(next_page_id),
       history_list_offset_(-1),
       history_list_length_(0),
       target_url_status_(TARGET_NONE),
       selection_text_offset_(0),
       cached_is_main_frame_pinned_to_left_(false),
       cached_is_main_frame_pinned_to_right_(false),
       cached_has_main_frame_horizontal_scrollbar_(false),
       cached_has_main_frame_vertical_scrollbar_(false),
       context_has_swapbuffers_complete_callback_(false),
       queried_for_swapbuffers_complete_callback_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       geolocation_dispatcher_(NULL),
+      guest_observer_(NULL),
       input_tag_speech_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       media_stream_dispatcher_(NULL),
       p2p_socket_dispatcher_(NULL),
       devtools_agent_(NULL),
       renderer_accessibility_(NULL),
       mouse_lock_dispatcher_(NULL),
       session_storage_namespace_id_(session_storage_namespace_id),
       handling_select_range_(false),
 #if defined(OS_WIN)
       focused_plugin_id_(-1),
 #endif
+      guest_(guest),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)) {
   routing_id_ = routing_id;
   surface_id_ = surface_id;
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
   // Ensure we start with a valid next_page_id_ from the browser.
   DCHECK_GE(next_page_id_, 0);
 
 #if defined(ENABLE_NOTIFICATIONS)
@@ skipping 16 matching lines @@
 
   RenderThread::Get()->AddRoute(routing_id_, this);
   // Take a reference on behalf of the RenderThread.  This will be balanced
   // when we receive ViewMsg_ClosePage.
   AddRef();
 
   // If this is a popup, we must wait for the CreatingNew_ACK message before
   // completing initialization.  Otherwise, we can finish it now.
   if (opener_id == MSG_ROUTING_NONE) {
     did_show_ = true;
-    CompleteInit(parent_hwnd);
+    // TODO(fsamuel): Telling the RenderView to delay
+    // deferred updates doesn't seem to work correctly.
+    // This needs more investigation.
+    CompleteInit(parent_hwnd, false);
   }
 
   g_view_map.Get().insert(std::make_pair(webview(), this));
   webkit_preferences_.Apply(webview());
+
+  // This needs to be before initializeMainFrame it seems.
+  // PpapiMsg_CreateChannel messages can get lost if the guest
+  // observer has not been constructed before a sync message.
+  if (!guest_observer_)
+    guest_observer_ = new GuestRenderViewObserver(this);
+
   webview()->initializeMainFrame(this);
   if (!frame_name.empty())
     webview()->mainFrame()->setName(frame_name);
   webview()->settings()->setMinimumTimerInterval(
       is_hidden() ? webkit_glue::kBackgroundTabTimerInterval :
           webkit_glue::kForegroundTabTimerInterval);
 
   OnSetRendererPrefs(renderer_prefs);
 
   host_window_ = parent_hwnd;
@@ skipping 102 matching lines @@
     gfx::NativeViewId parent_hwnd,
     int32 opener_id,
     const content::RendererPreferences& renderer_prefs,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id,
     int32 surface_id,
     int64 session_storage_namespace_id,
     const string16& frame_name,
     int32 next_page_id,
-    const WebKit::WebScreenInfo& screen_info) {
+    const WebKit::WebScreenInfo& screen_info,
+    bool guest) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
   return new RenderViewImpl(
       parent_hwnd,
       opener_id,
       renderer_prefs,
       webkit_prefs,
       counter,
       routing_id,
       surface_id,
       session_storage_namespace_id,
       frame_name,
       next_page_id,
-      screen_info);
+      screen_info,
+      guest);
 }
 
 WebKit::WebPeerConnectionHandler* RenderViewImpl::CreatePeerConnectionHandler(
     WebKit::WebPeerConnectionHandlerClient* client) {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   if (!cmd_line->HasSwitch(switches::kEnableMediaStream))
     return NULL;
   EnsureMediaStreamImpl();
   if (!media_stream_impl_.get())
     return NULL;
@@ skipping 173 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_SetInLiveResize, OnSetInLiveResize)
 #endif
     IPC_MESSAGE_HANDLER(ViewMsg_SetHistoryLengthAndPrune,
                         OnSetHistoryLengthAndPrune)
     IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode, OnEnableViewSourceMode)
     IPC_MESSAGE_HANDLER(JavaBridgeMsg_Init, OnJavaBridgeInit)
 
     // Have the super handle all other messages.
     IPC_MESSAGE_UNHANDLED(handled = RenderWidget::OnMessageReceived(message))
   IPC_END_MESSAGE_MAP()
-
   if (!msg_is_ok) {
     // The message had a handler, but its deserialization failed.
     // Kill the renderer to avoid potential spoofing attacks.
     CHECK(false) << "Unable to deserialize message in RenderViewImpl.";
   }
-
   return handled;
 }
 
 void RenderViewImpl::OnNavigate(const ViewMsg_Navigate_Params& params) {
   MaybeHandleDebugURL(params.url);
   if (!webview())
     return;
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, Navigate(params.url));
 
@@ skipping 613 matching lines @@
   int64 cloned_session_storage_namespace_id;
 
   RenderThread::Get()->Send(
       new ViewHostMsg_CreateWindow(params,
                                    &routing_id,
                                    &surface_id,
                                    &cloned_session_storage_namespace_id));
   if (routing_id == MSG_ROUTING_NONE)
     return NULL;
 
+  // TODO(fsamuel): The host renderer needs to be able to
+  // control whether the guest renderer is allowed to do this
+  // or not. This current behavior is not well defined.
   RenderViewImpl* view = RenderViewImpl::Create(
       0,
       routing_id_,
       renderer_preferences_,
       webkit_preferences_,
       shared_popup_counter_,
       routing_id,
       surface_id,
       cloned_session_storage_namespace_id,
       frame_name,
       1,
-      screen_info_);
+      screen_info_,
+      guest_);
   view->opened_by_user_gesture_ = params.user_gesture;
 
   // Record whether the creator frame is trying to suppress the opener field.
   view->opener_suppressed_ = params.opener_suppressed;
 
   // Record the security origin of the creator.
   GURL creator_url(creator->document().securityOrigin().toString().utf8());
   if (!creator_url.is_valid() || !creator_url.IsStandard())
     creator_url = GURL();
   view->creator_url_ = creator_url;
@@ skipping 51 matching lines @@
 WebGraphicsContext3D* RenderViewImpl::createGraphicsContext3D(
     const WebGraphicsContext3D::Attributes& attributes) {
   return createGraphicsContext3D(attributes, true);
 }
 
 WebGraphicsContext3D* RenderViewImpl::createGraphicsContext3D(
     const WebGraphicsContext3D::Attributes& attributes,
     bool direct) {
   if (!webview())
     return NULL;
+
+  if (guest_observer_ && guest_observer_->GetWebGraphicsContext3D())
+    return guest_observer_->GetWebGraphicsContext3D();
   // The WebGraphicsContext3DInProcessImpl code path is used for
   // layout tests (though not through this code) as well as for
   // debugging and bringing up new ports.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessWebGL)) {
     return webkit::gpu::WebGraphicsContext3DInProcessImpl::CreateForWebView(
         attributes, direct);
   } else {
     int surface = direct ? surface_id() : 0;
 
     GURL url;
@@ skipping 494 matching lines @@
 
 bool RenderViewImpl::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
 // WebKit::WebFrameClient -----------------------------------------------------
 
 WebPlugin* RenderViewImpl::createPlugin(WebFrame* frame,
                                         const WebPluginParams& params) {
+
+  // The browser plugin is a special kind of pepper plugin
+  // that loads asynchronously. We first create a placeholder here.
+  // When a guest is ready to be displayed, we swap out the placeholder
+  // with the guest.
+  if (UTF16ToASCII(params.mimeType) == kBrowserPluginMimeType)
+    return BrowserPluginPlaceholder::Create(this, frame, params);
+
   WebPlugin* plugin = NULL;
   if (content::GetContentClient()->renderer()->OverrideCreatePlugin(
           this, frame, params, &plugin)) {
     return plugin;
   }
 
   webkit::WebPluginInfo info;
   std::string mime_type;
   bool found = GetPluginInfo(params.url, frame->top()->document().url(),
                              params.mimeType.utf8(), &info, &mime_type);
@@ skipping 1349 matching lines @@
     if (node.isContentEditable()) {
       is_editable_node = true;
     } else if (node.isElementNode()) {
       is_editable_node =
           node.toConst<WebElement>().isTextFormControlElement();
     }
   }
   return is_editable_node;
 }
 
+WebKit::WebPlugin* RenderViewImpl::CreateBrowserPlugin(
+    base::ProcessHandle process_handle,
+    const IPC::ChannelHandle& channel_handle,
+    const WebKit::WebPluginParams& params) {
+  // We do not currently support guests hosting guests.
+  DCHECK(!guest_);
+  scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
+      pepper_delegate_.CreateBrowserPluginModule(process_handle,
+                                                 channel_handle));
+  return new webkit::ppapi::WebPluginImpl(
+      pepper_module.get(), params, pepper_delegate_.AsWeakPtr());
+}
+
 WebKit::WebPlugin* RenderViewImpl::CreatePlugin(
     WebKit::WebFrame* frame,
     const webkit::WebPluginInfo& info,
     const WebKit::WebPluginParams& params)  {
+
   bool pepper_plugin_was_registered = false;
   scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
       pepper_delegate_.CreatePepperPluginModule(info,
                                                 &pepper_plugin_was_registered));
   if (pepper_plugin_was_registered) {
     if (!pepper_module)
       return NULL;
     return new webkit::ppapi::WebPluginImpl(
         pepper_module.get(), params, pepper_delegate_.AsWeakPtr());
   }
@@ skipping 1029 matching lines @@
 }
 
 void RenderViewImpl::OnViewContextSwapBuffersComplete() {
   RenderWidget::OnSwapBuffersComplete();
 }
 
 void RenderViewImpl::OnViewContextSwapBuffersAborted() {
   RenderWidget::OnSwapBuffersAborted();
 }
 
+void RenderViewImpl::OnGuestReady() {
+  host_window_set_ = true;
+  DoDeferredUpdate();
+}
+
 webkit::ppapi::PluginInstance* RenderViewImpl::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip) {
   return pepper_delegate_.GetBitmapForOptimizedPluginPaint(
       paint_bounds, dib, location, clip);
 }
 
 gfx::Point RenderViewImpl::GetScrollOffset() {
@@ skipping 619 matching lines @@
 bool RenderViewImpl::WebWidgetHandlesCompositorScheduling() const {
   return !!RenderThreadImpl::current()->compositor_thread();
 }
 
 void RenderViewImpl::OnJavaBridgeInit() {
   DCHECK(!java_bridge_dispatcher_.get());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_.reset(new JavaBridgeDispatcher(this));
 #endif
 }