Create a visible window with class name Chrome_RenderWidgetHostHWND which corresponds to the bounds…

content/browser/renderer_host/render_widget_host_view_aura.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/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 65 matching lines @@
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/wm/public/window_types.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_win.h"
+#include "content/browser/renderer_host/legacy_render_widget_host_win.h"
 #include "content/common/plugin_constants_win.h"
 #include "ui/base/win/hidden_window.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/win/dpi.h"
 #endif
 
 using gfx::RectToSkIRect;
 using gfx::SkIRectToRect;
 
 using blink::WebScreenInfo;
@@ skipping 397 matching lines @@
   host_->SetView(this);
   window_observer_.reset(new WindowObserver(this));
   aura::client::SetTooltipText(window_, &tooltip_);
   aura::client::SetActivationDelegate(window_, this);
   aura::client::SetActivationChangeObserver(window_, this);
   aura::client::SetFocusChangeObserver(window_, this);
   gfx::Screen::GetScreenFor(window_)->AddObserver(this);
   software_frame_manager_.reset(new SoftwareFrameManager(
       weak_ptr_factory_.GetWeakPtr()));
 #if defined(OS_WIN)
-  plugin_parent_window_ = NULL;
+  legacy_render_widget_host_HWND_ = NULL;
 #endif
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, RenderWidgetHostView implementation:
 
 bool RenderWidgetHostViewAura::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
@@ skipping 113 matching lines @@
       !released_front_lock_.get()) {
     ui::Compositor* compositor = GetCompositor();
     if (compositor)
       released_front_lock_ = compositor->GetCompositorLock();
   }
 
 #if defined(OS_WIN)
   LPARAM lparam = reinterpret_cast<LPARAM>(this);
   EnumChildWindows(ui::GetHiddenWindow(), ShowWindowsCallback, lparam);
 
-  if (::IsWindow(plugin_parent_window_)) {
-    gfx::Rect window_bounds = window_->GetBoundsInRootWindow();
-    ::SetWindowPos(plugin_parent_window_, NULL, window_bounds.x(),
-                   window_bounds.y(), window_bounds.width(),
-                   window_bounds.height(), 0);
+  if (legacy_render_widget_host_HWND_) {
+    legacy_render_widget_host_HWND_->SetBounds(
+        window_->GetBoundsInRootWindow());
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::WasHidden() {
   if (!host_ || host_->is_hidden())
     return;
   host_->WasHidden();
   software_frame_manager_->SetVisibility(false);
   delegated_frame_evictor_->SetVisible(false);
   released_front_lock_ = NULL;
 
 #if defined(OS_WIN)
   constrained_rects_.clear();
   aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   if (dispatcher) {
     HWND parent = dispatcher->host()->GetAcceleratedWidget();
     LPARAM lparam = reinterpret_cast<LPARAM>(this);
 
     EnumChildWindows(parent, HideWindowsCallback, lparam);
   }
-  if (::IsWindow(plugin_parent_window_))
-    ::SetWindowPos(plugin_parent_window_, NULL, 0, 0, 0, 0, 0);
 #endif
 }
 
 void RenderWidgetHostViewAura::SetSize(const gfx::Size& size) {
   // For a SetSize operation, we don't care what coordinate system the origin
   // of the window is in, it's only important to make sure that the origin
   // remains constant after the operation.
   InternalSetBounds(gfx::Rect(window_->bounds().origin(), size));
 }
 
@@ skipping 198 matching lines @@
   return window_->HasFocus();
 }
 
 bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
   return CanCopyToBitmap() || !!host_->GetBackingStore(false);
 }
 
 void RenderWidgetHostViewAura::Show() {
   window_->Show();
   WasShown();
+#if defined(OS_WIN)
+  if (legacy_render_widget_host_HWND_)
+    legacy_render_widget_host_HWND_->Show();
+#endif
 }
 
 void RenderWidgetHostViewAura::Hide() {
   window_->Hide();
   WasHidden();
+#if defined(OS_WIN)
+  if (legacy_render_widget_host_HWND_)
+    legacy_render_widget_host_HWND_->Hide();
+#endif
 }
 
 bool RenderWidgetHostViewAura::IsShowing() {
   return window_->IsVisible();
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetViewBounds() const {
   // This is the size that we want the renderer to produce. While we're waiting
   // for the correct frame (i.e. during a resize), don't change the size so that
   // we don't pipeline more resizes than we can handle.
@@ skipping 323 matching lines @@
   // a Window::SetBoundsInternal call.
   if (!in_bounds_changed_)
     window_->SetBounds(rect);
   host_->WasResized();
   MaybeCreateResizeLock();
   if (touch_editing_client_) {
     touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
       selection_focus_rect_);
   }
 #if defined(OS_WIN)
-  // Create the dummy plugin parent window which will be passed as the
-  // container window to windowless plugins.
+  // Create the legacy dummy window which corresponds to the bounds of the
+  // webcontents. This will be passed as the container window for windowless
+  // plugins.
   // Plugins like Flash assume the container window which is returned via the
   // NPNVnetscapeWindow property corresponds to the bounds of the webpage.
   // This is not true in Aura where we have only HWND which is the main Aura
   // window. If we return this window to plugins like Flash then it causes the
   // coordinate translations done by these plugins to break.
-  if (!plugin_parent_window_ && GetNativeViewId()) {
-    plugin_parent_window_ = ::CreateWindowEx(
-        0, L"Static", NULL, WS_CHILDWINDOW, 0, 0, 0, 0,
-        reinterpret_cast<HWND>(GetNativeViewId()), NULL, NULL, NULL);
-    if (::IsWindow(plugin_parent_window_))
-      ::SetProp(plugin_parent_window_, content::kPluginDummyParentProperty,
-                reinterpret_cast<HANDLE>(true));
-  }
-  if (::IsWindow(plugin_parent_window_)) {
-    gfx::Rect window_bounds = window_->GetBoundsInRootWindow();
-    ::SetWindowPos(plugin_parent_window_, NULL, window_bounds.x(),
-                   window_bounds.y(), window_bounds.width(),
-                   window_bounds.height(), 0);
+  // Additonally the legacy dummy window is needed for accessibility and for
+  // scrolling to work in legacy drivers for trackpoints/trackpads, etc.
+  if (GetNativeViewId()) {
+    if (!legacy_render_widget_host_HWND_) {
+      legacy_render_widget_host_HWND_ = new LegacyRenderWidgetHostHWND(
+          reinterpret_cast<HWND>(GetNativeViewId()));
+    }
+    legacy_render_widget_host_HWND_->SetBounds(
+        window_->GetBoundsInRootWindow());
   }
 #endif
 }
 
 void RenderWidgetHostViewAura::CheckResizeLock() {
   if (!resize_lock_ || resize_lock_->expected_size() != current_frame_size_)
     return;
 
   // Since we got the size we were looking for, unlock the compositor. But delay
   // the release of the lock until we've kicked a frame with the new texture, to
@@ skipping 449 matching lines @@
 void RenderWidgetHostViewAura::SetParentNativeViewAccessible(
     gfx::NativeViewAccessible accessible_parent) {
   if (GetBrowserAccessibilityManager()) {
     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerWin()
         ->set_parent_iaccessible(accessible_parent);
   }
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetParentForWindowlessPlugin()
     const {
-  return reinterpret_cast<gfx::NativeViewId>(plugin_parent_window_);
+  if (legacy_render_widget_host_HWND_) {
+    return reinterpret_cast<gfx::NativeViewId>(
+        legacy_render_widget_host_HWND_->hwnd());
+  }
+  return NULL;
 }
 #endif
 
 void RenderWidgetHostViewAura::BuffersSwapped(
     const gfx::Size& surface_size,
     const gfx::Rect& damage_rect,
     float surface_scale_factor,
     const std::string& mailbox_name,
     const std::vector<ui::LatencyInfo>& latency_info,
     const BufferPresentedCallback& ack_callback) {
@@ skipping 480 matching lines @@
     return;
   HWND hwnd = dispatcher->host()->GetAcceleratedWidget();
 
   // The accessible_parent may be NULL at this point. The WebContents will pass
   // it down to this instance (by way of the RenderViewHost and
   // RenderWidgetHost) when it is known. This instance will then set it on its
   // BrowserAccessibilityManager.
   gfx::NativeViewAccessible accessible_parent =
       host_->GetParentNativeViewAccessible();
 
-  BrowserAccessibilityManager* manager = new BrowserAccessibilityManagerWin(
-      hwnd, accessible_parent,
+    BrowserAccessibilityManager* manager = new BrowserAccessibilityManagerWin(
+      legacy_render_widget_host_HWND_, accessible_parent,
       BrowserAccessibilityManagerWin::GetEmptyDocument(), this);
 #else
   BrowserAccessibilityManager* manager = BrowserAccessibilityManager::Create(
       BrowserAccessibilityManager::GetEmptyDocument(), this);
 #endif
 
   SetBrowserAccessibilityManager(manager);
 }
 
 gfx::GLSurfaceHandle RenderWidgetHostViewAura::GetCompositingSurface() {
@@ skipping 1115 matching lines @@
   // destroyed, as it may then outlive the GLHelper.
   for (std::set<OwnedMailbox*>::iterator it =
            active_frame_subscriber_textures_.begin();
        it != active_frame_subscriber_textures_.end();
        ++it) {
     (*it)->Destroy();
   }
   active_frame_subscriber_textures_.clear();
 
 #if defined(OS_WIN)
-  if (::IsWindow(plugin_parent_window_))
-    ::DestroyWindow(plugin_parent_window_);
+  if (legacy_render_widget_host_HWND_)

[sky, 2014/02/05 18:16:47]

nit: no need for if.

[ananta, 2014/02/05 19:52:36]

Code has been changed to call legacy_render_widget_host_HWND_.reset(NULL) as it
is a scoped_ptr

+    delete legacy_render_widget_host_HWND_;
 #endif
 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
   const gfx::Point screen_point =
       gfx::Screen::GetScreenFor(GetNativeView())->GetCursorScreenPoint();
   aura::Window* root_window = window_->GetRootWindow();
   if (!root_window)
     return;
 
@@ skipping 142 matching lines @@
     cursor_client->AddObserver(this);
     NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
   if (current_surface_.get())
     UpdateExternalTexture();
   if (HasFocus()) {
     ui::InputMethod* input_method = GetInputMethod();
     if (input_method)
       input_method->SetFocusedTextInputClient(this);
   }
+#if defined(OS_WIN)
+  if (legacy_render_widget_host_HWND_ && GetNativeViewId()) {

[sky, 2014/02/05 18:16:47]

Can you instead destroy in RemoveFromRootWindow and recreate here?

[ananta, 2014/02/05 19:52:36]

I don't think destroying and creating would work given that the same code
executes when a tab is reparented to a new window etc. Plugins request the HWND
once and hold on to it.

[sky, 2014/02/05 21:56:15]

My worry is that I don't know if you are guaranteed a Remove is immediately
followed by an add. If it's not immediate than you've left the
legacy_render_widget_host_HWND_ in the wrong window, and it may end up being
destroyed by virtue of being a child. I think you need to change the parent in
both remove and add.

+    // The parent may have changed here. Ensure that the legacy window is
+    // reparented accordingly.
+    legacy_render_widget_host_HWND_->SetParentWindow(
+        reinterpret_cast<HWND>(GetNativeViewId()));
+  }
+#endif
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   DetachFromInputMethod();
 
@@ skipping 44 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content