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

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 <memory>
 
@@ skipping 610 matching lines @@
       history_list_offset_(-1),
       history_list_length_(0),
       frames_in_progress_(0),
       target_url_status_(TARGET_NONE),
       uses_temporary_zoom_level_(false),
 #if defined(OS_ANDROID)
       top_controls_constraints_(TOP_CONTROLS_STATE_BOTH),
 #endif
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0.f),
-      has_focus_(false),
       webview_(nullptr),
       has_scrolled_focused_editable_node_into_rect_(false),
       page_zoom_level_(params.page_zoom_level),
       main_render_frame_(nullptr),
       frame_widget_(nullptr),
       speech_recognition_dispatcher_(NULL),
       mouse_lock_dispatcher_(NULL),
 #if defined(OS_ANDROID)
       expected_content_intent_id_(0),
 #endif
-#if defined(ENABLE_PLUGINS)
-      focused_pepper_plugin_(NULL),
-      pepper_last_mouse_event_target_(NULL),
-#endif
       enumeration_completion_id_(0),
       session_storage_namespace_id_(params.session_storage_namespace_id) {
   GetWidget()->set_owner_delegate(this);
 }
 
 void RenderViewImpl::Initialize(const ViewMsg_New_Params& params,
                                 bool was_created_by_renderer) {
   SetRoutingID(params.view_id);
 
   int opener_view_routing_id;
@@ skipping 494 matching lines @@
 void RenderViewImpl::RemoveObserver(RenderViewObserver* observer) {
   observer->RenderViewGone();
   observers_.RemoveObserver(observer);
 }
 
 blink::WebView* RenderViewImpl::webview() const {
   return webview_;
 }
 
 #if defined(ENABLE_PLUGINS)
-void RenderViewImpl::PepperInstanceCreated(
-    PepperPluginInstanceImpl* instance) {
-  active_pepper_instances_.insert(instance);
-
-  RenderFrameImpl* const render_frame = instance->render_frame();
-  render_frame->Send(
-      new FrameHostMsg_PepperInstanceCreated(render_frame->GetRoutingID()));
-}
-
-void RenderViewImpl::PepperInstanceDeleted(
-    PepperPluginInstanceImpl* instance) {
-  active_pepper_instances_.erase(instance);
-
-  if (pepper_last_mouse_event_target_ == instance)
-    pepper_last_mouse_event_target_ = NULL;
-  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 RenderViewImpl::PepperFocusChanged(PepperPluginInstanceImpl* instance,
-                                        bool focused) {
-  if (focused)
-    focused_pepper_plugin_ = instance;
-  else if (focused_pepper_plugin_ == instance)
-    focused_pepper_plugin_ = NULL;
-
-  UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
-  UpdateSelectionBounds();
-}
 
 #if defined(OS_MACOSX)
 void RenderViewImpl::OnGetRenderedText() {
   if (!webview())
     return;
 
   if (!webview()->mainFrame()->isWebLocalFrame())
     return;
 
   // Get rendered text from WebLocalFrame.
@@ skipping 47 matching lines @@
   return false;
 }
 
 bool RenderViewImpl::RenderWidgetWillHandleMouseEvent(
     const blink::WebMouseEvent& event) {
   possible_drag_event_info_.event_source =
       ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE;
   possible_drag_event_info_.event_location =
       gfx::Point(event.globalX, event.globalY);
 
-#if defined(ENABLE_PLUGINS)
-  // This method is called for every mouse event that the render view receives.
-  // And then the mouse event is forwarded to WebKit, 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_ = NULL;
-#endif
-
   // If the mouse is locked, only the current owner of the mouse lock can
   // process mouse events.
   return mouse_lock_dispatcher_->WillHandleMouseEvent(event);
 }
 
 // IPC::Listener implementation ----------------------------------------------
 
 bool RenderViewImpl::OnMessageReceived(const IPC::Message& message) {
   WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
   if (main_frame && main_frame->isWebLocalFrame())
@@ skipping 1439 matching lines @@
 
   top_controls_shrink_blink_size_ = params.top_controls_shrink_blink_size;
   top_controls_height_ = params.top_controls_height;
 
   RenderWidget::OnResize(params);
 
   if (old_visible_viewport_size != visible_viewport_size_)
     has_scrolled_focused_editable_node_into_rect_ = false;
 }
 
-void RenderViewImpl::RenderWidgetDidCommitAndDrawCompositorFrame() {
-#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 (PepperPluginSet::iterator i = plugins.begin(); i != plugins.end(); ++i) {
-    if (active_pepper_instances_.find(*i) != active_pepper_instances_.end())
-      (*i)->ViewInitiatedPaint();
-  }
-#endif
-}
-
 void RenderViewImpl::RenderWidgetDidFlushPaint() {
   // If the RenderWidget is closing down then early-exit, otherwise we'll crash.
   // See crbug.com/112921.
   if (!webview())
     return;
 
   WebFrame* main_frame = webview()->mainFrame();
   for (WebFrame* frame = main_frame; frame;
        frame = frame->traverseNext(false)) {
     // TODO(nasko): This is a hack for the case in which the top-level
@@ skipping 72 matching lines @@
 
 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
   RenderThreadImpl::current()->video_capture_impl_manager()->
       SuspendDevices(true);
   if (speech_recognition_dispatcher_)
     speech_recognition_dispatcher_->AbortAllRecognitions();
 #endif
 
   if (webview())
     webview()->setVisibilityState(visibilityState(), false);
-
-#if defined(ENABLE_PLUGINS)
-  for (PepperPluginSet::iterator i = active_pepper_instances_.begin();
-       i != active_pepper_instances_.end(); ++i)
-    (*i)->PageVisibilityChanged(false);
-#endif  // ENABLE_PLUGINS
 }
 
 void RenderViewImpl::OnWasShown(bool needs_repainting,
                                 const ui::LatencyInfo& latency_info) {
   RenderWidget::OnWasShown(needs_repainting, latency_info);
 
 #if defined(OS_ANDROID) && defined(ENABLE_WEBRTC)
   RenderThreadImpl::current()->video_capture_impl_manager()->
       SuspendDevices(false);
 #endif
 
   if (webview())
     webview()->setVisibilityState(visibilityState(), false);
-
-#if defined(ENABLE_PLUGINS)
-  for (PepperPluginSet::iterator i = active_pepper_instances_.begin();
-       i != active_pepper_instances_.end(); ++i)
-    (*i)->PageVisibilityChanged(true);
-#endif  // ENABLE_PLUGINS
 }
 
 GURL RenderViewImpl::GetURLForGraphicsContext3D() {
   DCHECK(webview());
   if (webview()->mainFrame()->isWebLocalFrame())
     return GURL(webview()->mainFrame()->document().url());
   else
     return GURL("chrome://gpu/RenderViewImpl::CreateGraphicsContext3D");
 }
 
 void RenderViewImpl::OnSetFocus(bool enable) {
   // This message must always be received when the main frame is a
   // WebLocalFrame.
   CHECK(webview()->mainFrame()->isWebLocalFrame());
   SetFocus(enable);
 }
 
 void RenderViewImpl::SetFocus(bool enable) {
-  has_focus_ = enable;
   RenderWidget::OnSetFocus(enable);
 
-#if defined(ENABLE_PLUGINS)
-  // Notify all Pepper plugins.
-  for (PepperPluginSet::iterator i = active_pepper_instances_.begin();
-       i != active_pepper_instances_.end(); ++i)
-    (*i)->SetContentAreaFocus(enable);
-#endif
   // Notify all BrowserPlugins of the RenderView's focus state.
   if (BrowserPluginManager::Get())
     BrowserPluginManager::Get()->UpdateFocusState();
 }
 
 void RenderViewImpl::OnImeSetComposition(
     const base::string16& text,
     const std::vector<blink::WebCompositionUnderline>& underlines,
     const gfx::Range& replacement_range,
     int selection_start,
     int selection_end) {
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_) {
-    focused_pepper_plugin_->render_frame()->OnImeSetComposition(
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin) {
+    focused_pepper_plugin->render_frame()->OnImeSetComposition(
         text, underlines, selection_start, selection_end);
     return;
   }
 #endif  // ENABLE_PLUGINS
   if (replacement_range.IsValid() && webview()) {
     // Select the text in |replacement_range|, it will then be replaced by
     // text added by the call to RenderWidget::OnImeSetComposition().
     if (WebLocalFrame* frame = webview()->focusedFrame()->toWebLocalFrame()) {
       WebRange webrange = WebRange::fromDocumentRange(
           frame, replacement_range.start(), replacement_range.length());
       if (!webrange.isNull())
         frame->selectRange(webrange);
     }
   }
   RenderWidget::OnImeSetComposition(text,
                                     underlines,
                                     replacement_range,
                                     selection_start,
                                     selection_end);
 }
 
 void RenderViewImpl::OnImeConfirmComposition(
     const base::string16& text,
     const gfx::Range& replacement_range,
     bool keep_selection) {
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_) {
-    focused_pepper_plugin_->render_frame()->OnImeConfirmComposition(
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin) {
+    focused_pepper_plugin->render_frame()->OnImeConfirmComposition(
         text, replacement_range, keep_selection);
     return;
   }
 #endif  // ENABLE_PLUGINS
   if (replacement_range.IsValid() && webview()) {
     // Select the text in |replacement_range|, it will then be replaced by
     // text added by the call to RenderWidget::OnImeConfirmComposition().
     if (WebLocalFrame* frame = webview()->focusedFrame()->toWebLocalFrame()) {
       WebRange webrange = WebRange::fromDocumentRange(
           frame, replacement_range.start(), replacement_range.length());
@@ skipping 15 matching lines @@
       webview()->resetDeviceColorProfileForTesting();
     } else {
       WebVector<char> colorProfile = profile;
       webview()->setDeviceColorProfile(colorProfile);
     }
   }
 }
 
 ui::TextInputType RenderViewImpl::GetTextInputType() {
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_)
-    return focused_pepper_plugin_->text_input_type();
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin)
+    return focused_pepper_plugin->text_input_type();
 #endif
   return RenderWidget::GetTextInputType();
 }
 
 void RenderViewImpl::GetSelectionBounds(gfx::Rect* start, gfx::Rect* end) {
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_) {
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin) {
     // TODO(kinaba) http://crbug.com/101101
     // Current Pepper IME API does not handle selection bounds. So we simply
     // use the caret position as an empty range for now. It will be updated
     // after Pepper API equips features related to surrounding text retrieval.
-    blink::WebRect caret(focused_pepper_plugin_->GetCaretBounds());
+    blink::WebRect caret(focused_pepper_plugin->GetCaretBounds());
     ConvertViewportToWindowViaWidget(&caret);
     *start = caret;
     *end = caret;
     return;
   }
 #endif
   RenderWidget::GetSelectionBounds(start, end);
 }
 
 void RenderViewImpl::GetCompositionCharacterBounds(
     std::vector<gfx::Rect>* bounds_in_window) {
   DCHECK(bounds_in_window);
   bounds_in_window->clear();
 
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_) {
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin)
     return;
-  }
 #endif
 
   if (!webview())
     return;
   size_t start_offset = 0;
   size_t character_count = 0;
   if (!webview()->compositionRange(&start_offset, &character_count))
     return;
   if (character_count == 0)
     return;
@@ skipping 10 matching lines @@
       bounds_in_window->clear();
       return;
     }
     ConvertViewportToWindowViaWidget(&webrect);
     bounds_in_window->push_back(webrect);
   }
 }
 
 void RenderViewImpl::GetCompositionRange(gfx::Range* range) {
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_) {
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin)
     return;
-  }
 #endif
   RenderWidget::GetCompositionRange(range);
 }
 
 bool RenderViewImpl::CanComposeInline() {
 #if defined(ENABLE_PLUGINS)
-  if (focused_pepper_plugin_)
-    return focused_pepper_plugin_->IsPluginAcceptingCompositionEvents();
+  PepperPluginInstanceImpl* focused_pepper_plugin = GetFocusedPepperPlugin();
+  if (focused_pepper_plugin)
+    return focused_pepper_plugin->IsPluginAcceptingCompositionEvents();
 #endif
   return true;
 }
 
 void RenderViewImpl::DidCompletePageScaleAnimation() {
   GetWidget()->FocusChangeComplete();
 }
 
 void RenderViewImpl::OnDeviceScaleFactorChanged() {
   RenderWidget::OnDeviceScaleFactorChanged();
@@ skipping 378 matching lines @@
     return;
   if (IsUseZoomForDSFEnabled()) {
     webview()->setZoomFactorForDeviceScaleFactor(device_scale_factor_);
   } else {
     webview()->setDeviceScaleFactor(device_scale_factor_);
   }
   webview()->settings()->setPreferCompositingToLCDTextEnabled(
       PreferCompositingToLCDText(compositor_deps_, device_scale_factor_));
 }
 
+#if defined(ENABLE_PLUGINS)
+PepperPluginInstanceImpl* RenderViewImpl::GetFocusedPepperPlugin() {
+  blink::WebFrame* frame = GetWebView()->mainFrame();
+
+  while (frame) {
+    if (frame->isWebLocalFrame()) {
+      RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame);
+      if (render_frame->focused_pepper_plugin())
+        return render_frame->focused_pepper_plugin();
+    }
+    frame = frame->traverseNext(false);
+  }
+
+  return nullptr;
+}
+#endif
+
 }  // namespace content