Fix rendering of flash content inside an out-of-process iframe.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 167 matching lines @@
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSearchableFormData.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebSerializedScriptValue.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebSurroundingText.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "third_party/WebKit/public/web/WebWidget.h"
 #include "url/url_constants.h"
 #include "url/url_util.h"
 
 #if defined(ENABLE_PLUGINS)
 #include "content/renderer/pepper/pepper_browser_connection.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
+#include "content/renderer/pepper/pepper_plugin_registry.h"
 #include "content/renderer/pepper/pepper_webplugin_impl.h"
 #include "content/renderer/pepper/plugin_module.h"
 #endif
 
 #if defined(ENABLE_WEBRTC)
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include <cpu-features.h>
@@ skipping 816 matching lines @@
       blink_service_registry_(service_registry_.GetWeakPtr()),
       screen_orientation_dispatcher_(NULL),
       manifest_manager_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       media_player_delegate_(NULL),
       is_using_lofi_(false),
       is_pasting_(false),
       suppress_further_dialogs_(false),
       blame_context_(nullptr),
+#if defined(ENABLE_PLUGINS)
+      focused_pepper_plugin_(nullptr),
+      pepper_last_mouse_event_target_(nullptr),
+#endif
       weak_factory_(this) {
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   render_view_->RegisterRenderFrame(this);
 
   // Everything below subclasses RenderFrameObserver and is automatically
@@ skipping 104 matching lines @@
 }
 
 void RenderFrameImpl::PepperDidChangeCursor(
     PepperPluginInstanceImpl* instance,
     const blink::WebCursorInfo& cursor) {
   // Update the cursor appearance immediately if the requesting plugin is the
   // one which receives the last mouse event. Otherwise, the new cursor won't be
   // picked up until the plugin gets the next input event. That is bad if, e.g.,
   // the plugin would like to set an invisible cursor when there isn't any user
   // input for a while.
-  if (instance == render_view_->pepper_last_mouse_event_target())
+  if (instance == pepper_last_mouse_event_target_)
     GetRenderWidget()->didChangeCursor(cursor);
 }
 
 void RenderFrameImpl::PepperDidReceiveMouseEvent(
     PepperPluginInstanceImpl* instance) {
-  render_view_->set_pepper_last_mouse_event_target(instance);
+  set_pepper_last_mouse_event_target(instance);
 }
 
 void RenderFrameImpl::PepperTextInputTypeChanged(
     PepperPluginInstanceImpl* instance) {
-  if (instance != render_view_->focused_pepper_plugin())
+  if (instance != focused_pepper_plugin_)
     return;
 
   GetRenderWidget()->UpdateTextInputState(ShowIme::HIDE_IME,
                                           ChangeSource::FROM_NON_IME);
 
   FocusedNodeChangedForAccessibility(WebNode());
 }
 
 void RenderFrameImpl::PepperCaretPositionChanged(
     PepperPluginInstanceImpl* instance) {
-  if (instance != render_view_->focused_pepper_plugin())
+  if (instance != focused_pepper_plugin_)
     return;
   GetRenderWidget()->UpdateSelectionBounds();
 }
 
 void RenderFrameImpl::PepperCancelComposition(
     PepperPluginInstanceImpl* instance) {
-  if (instance != render_view_->focused_pepper_plugin())
+  if (instance != focused_pepper_plugin_)
     return;
   Send(new InputHostMsg_ImeCancelComposition(render_view_->GetRoutingID()));
 #if defined(OS_MACOSX) || defined(USE_AURA)
   GetRenderWidget()->UpdateCompositionInfo(true);
 #endif
 }
 
 void RenderFrameImpl::PepperSelectionChanged(
     PepperPluginInstanceImpl* instance) {
-  if (instance != render_view_->focused_pepper_plugin())
+  if (instance != focused_pepper_plugin_)
     return;
   SyncSelectionIfRequired();
 }
 
 RenderWidgetFullscreenPepper* RenderFrameImpl::CreatePepperFullscreenContainer(
     PepperPluginInstanceImpl* plugin) {
   GURL active_url;
   if (render_view_->webview() && render_view_->webview()->mainFrame())
     active_url = GURL(render_view_->webview()->mainFrame()->document().url());
   RenderWidgetFullscreenPepper* widget = RenderWidgetFullscreenPepper::Create(
       GetRenderWidget()->routing_id(), GetRenderWidget()->compositor_deps(),
       plugin, active_url, GetRenderWidget()->screenInfo());
   widget->show(blink::WebNavigationPolicyIgnore);
   return widget;
 }
 
 bool RenderFrameImpl::IsPepperAcceptingCompositionEvents() const {
-  if (!render_view_->focused_pepper_plugin())
+  if (!focused_pepper_plugin_)
     return false;
-  return render_view_->focused_pepper_plugin()->
-      IsPluginAcceptingCompositionEvents();
+  return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
 }
 
 void RenderFrameImpl::PluginCrashed(const base::FilePath& plugin_path,
                                    base::ProcessId plugin_pid) {
   // TODO(jam): dispatch this IPC in RenderFrameHost and switch to use
   // routing_id_ as a result.
   Send(new FrameHostMsg_PluginCrashed(routing_id_, plugin_path, plugin_pid));
 }
 
 void RenderFrameImpl::SimulateImeSetComposition(
@@ skipping 21 matching lines @@
   if (!IsPepperAcceptingCompositionEvents()) {
     pepper_composition_text_ = text;
   } else {
     // TODO(kinaba) currently all composition events are sent directly to
     // plugins. Use DOM event mechanism after WebKit is made aware about
     // plugins that support composition.
     // The code below mimics the behavior of WebCore::Editor::setComposition.
 
     // Empty -> nonempty: composition started.
     if (pepper_composition_text_.empty() && !text.empty()) {
-      render_view_->focused_pepper_plugin()->HandleCompositionStart(
-          base::string16());
+      focused_pepper_plugin_->HandleCompositionStart(base::string16());
     }
     // Nonempty -> empty: composition canceled.
     if (!pepper_composition_text_.empty() && text.empty()) {
-      render_view_->focused_pepper_plugin()->HandleCompositionEnd(
-          base::string16());
+      focused_pepper_plugin_->HandleCompositionEnd(base::string16());
     }
     pepper_composition_text_ = text;
     // Nonempty: composition is ongoing.
     if (!pepper_composition_text_.empty()) {
-      render_view_->focused_pepper_plugin()->HandleCompositionUpdate(
-          pepper_composition_text_, underlines, selection_start,
-          selection_end);
+      focused_pepper_plugin_->HandleCompositionUpdate(
+          pepper_composition_text_, underlines, selection_start, selection_end);
     }
   }
 }
 
 void RenderFrameImpl::OnImeConfirmComposition(
     const base::string16& text,
     const gfx::Range& replacement_range,
     bool keep_selection) {
   // When a PPAPI plugin has focus, we bypass WebKit.
   // Here, text.empty() has a special meaning. It means to commit the last
@@ skipping 23 matching lines @@
         char_event.text[i - char_start] = last_text[i];
         char_event.unmodifiedText[i - char_start] = last_text[i];
       }
 
       if (GetRenderWidget()->webwidget())
         GetRenderWidget()->webwidget()->handleInputEvent(char_event);
     }
   } else {
     // Mimics the order of events sent by WebKit.
     // See WebCore::Editor::setComposition() for the corresponding code.
-    render_view_->focused_pepper_plugin()->HandleCompositionEnd(last_text);
-    render_view_->focused_pepper_plugin()->HandleTextInput(last_text);
+    focused_pepper_plugin_->HandleCompositionEnd(last_text);
+    focused_pepper_plugin_->HandleTextInput(last_text);
   }
   pepper_composition_text_.clear();
 }
 #endif  // defined(ENABLE_PLUGINS)
 
 MediaStreamDispatcher* RenderFrameImpl::GetMediaStreamDispatcher() {
   if (!web_user_media_client_)
     InitializeUserMediaClient();
   return web_user_media_client_ ?
       web_user_media_client_->media_stream_dispatcher() : NULL;
@@ skipping 850 matching lines @@
                     DidMeaningfulLayout(layout_type));
 }
 
 void RenderFrameImpl::DidCommitCompositorFrame() {
   if (BrowserPluginManager::Get())
     BrowserPluginManager::Get()->DidCommitCompositorFrame(GetRoutingID());
   FOR_EACH_OBSERVER(
       RenderFrameObserver, observers_, DidCommitCompositorFrame());
 }
 
+void RenderFrameImpl::DidCommitAndDrawCompositorFrame() {
+#if defined(ENABLE_PLUGINS)
+  // Notify all instances that we painted.  The same caveats apply as for
+  // ViewFlushedPaint regarding instances closing themselves, so we take
+  // similar precautions.
+  PepperPluginSet plugins = active_pepper_instances_;
+  for (auto* plugin : plugins) {
+    if (active_pepper_instances_.find(plugin) != active_pepper_instances_.end())
+      plugin->ViewInitiatedPaint();
+  }
+#endif
+}
+
 RenderView* RenderFrameImpl::GetRenderView() {
   return render_view_.get();
 }
 
 int RenderFrameImpl::GetRoutingID() {
   return routing_id_;
 }
 
 blink::WebLocalFrame* RenderFrameImpl::GetWebFrame() {
   DCHECK(frame_);
@@ skipping 2111 matching lines @@
   DCHECK(frame_);
   frame_->stopLoading();
   if (!frame_->parent())
     FOR_EACH_OBSERVER(RenderViewObserver, render_view_->observers_, OnStop());
 
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnStop());
 }
 
 void RenderFrameImpl::WasHidden() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WasHidden());
+
+#if defined(ENABLE_PLUGINS)
+  for (auto* plugin : active_pepper_instances_)
+    plugin->PageVisibilityChanged(false);
+#endif  // ENABLE_PLUGINS
 }
 
 void RenderFrameImpl::WasShown() {
   // TODO(kenrb): Need to figure out how to do this better. Should
   // VisibilityState remain a page-level concept or move to frames?
   // The semantics of 'Show' might have to change here.
   // TODO(avi): This DCHECK is to track cleanup for https://crbug.com/545684
   DCHECK(!IsMainFrame() || render_widget_.get() == render_view_.get())
       << "The main render frame is no longer reusing the RenderView as its "
       << "RenderWidget!";
   if (render_widget_ && render_widget_->webwidget() &&
       render_view_.get() != render_widget_.get()) {
     static_cast<blink::WebFrameWidget*>(render_widget_->webwidget())->
         setVisibilityState(blink::WebPageVisibilityStateVisible, false);
   }
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WasShown());
+
+#if defined(ENABLE_PLUGINS)
+  for (auto* plugin : active_pepper_instances_)
+    plugin->PageVisibilityChanged(true);
+#endif  // ENABLE_PLUGINS
 }
 
 void RenderFrameImpl::WidgetWillClose() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WidgetWillClose());
 }
 
 bool RenderFrameImpl::IsMainFrame() {
   return is_main_frame_;
 }
 
@@ skipping 1106 matching lines @@
   // Only update main frame's encoding_name.
   if (!frame->parent())
     Send(new FrameHostMsg_UpdateEncoding(routing_id_, encoding_name));
 }
 
 void RenderFrameImpl::SyncSelectionIfRequired() {
   base::string16 text;
   size_t offset;
   gfx::Range range;
 #if defined(ENABLE_PLUGINS)
-  if (render_view_->focused_pepper_plugin_) {
-    render_view_->focused_pepper_plugin_->GetSurroundingText(&text, &range);
+  if (focused_pepper_plugin_) {
+    focused_pepper_plugin_->GetSurroundingText(&text, &range);
     offset = 0;  // Pepper API does not support offset reporting.
     // TODO(kinaba): cut as needed.
   } else
 #endif
   {
     size_t location, length;
     if (!GetRenderWidget()->webwidget()->caretOrSelectionRange(
             &location, &length)) {
       return;
     }
@@ skipping 549 matching lines @@
 void RenderFrameImpl::SendFindReply(int request_id,
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
+#if defined(ENABLE_PLUGINS)
+void RenderFrameImpl::PepperInstanceCreated(
+    PepperPluginInstanceImpl* instance) {
+  active_pepper_instances_.insert(instance);
+
+  Send(new FrameHostMsg_PepperInstanceCreated(routing_id_));
+}
+
+void RenderFrameImpl::PepperInstanceDeleted(
+    PepperPluginInstanceImpl* instance) {
+  active_pepper_instances_.erase(instance);
+
+  if (pepper_last_mouse_event_target_ == instance)
+    pepper_last_mouse_event_target_ = nullptr;
+  if (focused_pepper_plugin_ == instance)
+    PepperFocusChanged(instance, false);
+
+  RenderFrameImpl* const render_frame = instance->render_frame();
+  if (render_frame)
+    render_frame->Send(
+        new FrameHostMsg_PepperInstanceDeleted(render_frame->GetRoutingID()));
+}
+
+void RenderFrameImpl::PepperFocusChanged(PepperPluginInstanceImpl* instance,
+                                         bool focused) {
+  if (focused)
+    focused_pepper_plugin_ = instance;
+  else if (focused_pepper_plugin_ == instance)
+    focused_pepper_plugin_ = nullptr;
+
+  GetRenderWidget()->UpdateTextInputState(ShowIme::HIDE_IME,
+                                          ChangeSource::FROM_NON_IME);
+  GetRenderWidget()->UpdateSelectionBounds();
+}
+
+#endif  // ENABLE_PLUGINS
+
+void RenderFrameImpl::RenderWidgetSetFocus(bool enable) {
+#if defined(ENABLE_PLUGINS)
+  // Notify all Pepper plugins.
+  for (auto* plugin : active_pepper_instances_)
+    plugin->SetContentAreaFocus(enable);
+#endif
+}
+
+void RenderFrameImpl::RenderWidgetWillHandleMouseEvent() {
+#if defined(ENABLE_PLUGINS)
+  // This method is called for every mouse event that the RenderWidget receives.
+  // And then the mouse event is forwarded to blink, which dispatches it to the
+  // event target. Potentially a Pepper plugin will receive the event.
+  // In order to tell whether a plugin gets the last mouse event and which it
+  // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
+  // the event, it will notify us via DidReceiveMouseEvent() and set itself as
+  // |pepper_last_mouse_event_target_|.
+  pepper_last_mouse_event_target_ = nullptr;
+#endif
+}
+
 }  // namespace content