Create only a single LegacyRenderWidgetHostHWND per WebContentsViewAura.

content/browser/renderer_host/legacy_render_widget_host_win.cc

 // Copyright (c) 2014 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/legacy_render_widget_host_win.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/win/win_util.h"
 #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_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/common/content_switches.h"
 #include "ui/base/touch/touch_enabled.h"
 #include "ui/base/view_prop.h"
 #include "ui/base/win/internal_constants.h"
 #include "ui/base/win/window_event_target.h"
 #include "ui/display/win/screen_win.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/win/direct_manipulation.h"
 
 namespace content {
 
+namespace {
+
 // A custom MSAA object id used to determine if a screen reader or some
 // other client is listening on MSAA events - if so, we enable full web
 // accessibility support.
 const int kIdScreenReaderHoneyPot = 1;
 
+}  // namespace
+
+LegacyRenderWidgetHostHWND::~LegacyRenderWidgetHostHWND() {
+  // Re-enable flicks for just a moment
+  base::win::EnableFlicks(hwnd());
+
+  if (::IsWindow(hwnd()))
+    ::DestroyWindow(hwnd());
+}
+
 // static
 LegacyRenderWidgetHostHWND* LegacyRenderWidgetHostHWND::Create(
-    HWND parent) {
+    HWND parent,
+    LegacyRenderWidgetHostHWNDDelegate* delegate) {
   // content_unittests passes in the desktop window as the parent. We allow
   // the LegacyRenderWidgetHostHWND instance to be created in this case for
   // these tests to pass.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableLegacyIntermediateWindow) ||
       (!GetWindowEventTarget(parent) && parent != ::GetDesktopWindow()))
     return nullptr;
 
   LegacyRenderWidgetHostHWND* legacy_window_instance =
-      new LegacyRenderWidgetHostHWND(parent);
-  // If we failed to create the child, or if the switch to disable the legacy
-  // window is passed in, then return NULL.
+      new LegacyRenderWidgetHostHWND(parent, delegate);
+
+  // If we failed to create the child, return nullptr.
   if (!::IsWindow(legacy_window_instance->hwnd())) {
     delete legacy_window_instance;
-    return NULL;
+    return nullptr;
   }
   legacy_window_instance->Init();
   return legacy_window_instance;
 }
 
-void LegacyRenderWidgetHostHWND::Destroy() {
-  if (::IsWindow(hwnd()))
-    ::DestroyWindow(hwnd());
-}
-
 void LegacyRenderWidgetHostHWND::UpdateParent(HWND parent) {
   if (GetWindowEventTarget(GetParent()))
     GetWindowEventTarget(GetParent())->HandleParentChanged();
+
+  if (!::IsWindow(hwnd()))
+    return;
+
   ::SetParent(hwnd(), parent);
   // If the new parent is the desktop Window, then we disable the child window
   // to ensure that it does not receive any input events. It should not because
   // of WS_EX_TRANSPARENT. This is only for safety.
   if (parent == ::GetDesktopWindow()) {
     ::EnableWindow(hwnd(), FALSE);
   } else {
     ::EnableWindow(hwnd(), TRUE);
   }
 }
 
 HWND LegacyRenderWidgetHostHWND::GetParent() {
+  if (!::IsWindow(hwnd()))
+    return NULL;
+
   return ::GetParent(hwnd());
 }
 
 void LegacyRenderWidgetHostHWND::Show() {
-  ::ShowWindow(hwnd(), SW_SHOW);
+  if (::IsWindow(hwnd()))
+    ::ShowWindow(hwnd(), SW_SHOW);
 }
 
 void LegacyRenderWidgetHostHWND::Hide() {
-  ::ShowWindow(hwnd(), SW_HIDE);
+  if (::IsWindow(hwnd()))
+    ::ShowWindow(hwnd(), SW_HIDE);
 }
 
 void LegacyRenderWidgetHostHWND::SetBounds(const gfx::Rect& bounds) {
+  if (!::IsWindow(hwnd()))
+    return;
+
   gfx::Rect bounds_in_pixel = display::win::ScreenWin::DIPToClientRect(hwnd(),
                                                                        bounds);
   ::SetWindowPos(hwnd(), NULL, bounds_in_pixel.x(), bounds_in_pixel.y(),
                  bounds_in_pixel.width(), bounds_in_pixel.height(),
                  SWP_NOREDRAW);
   if (direct_manipulation_helper_)
     direct_manipulation_helper_->SetBounds(bounds_in_pixel);
 }
 
-void LegacyRenderWidgetHostHWND::OnFinalMessage(HWND hwnd) {
-  if (host_) {
-    host_->OnLegacyWindowDestroyed();
-    host_ = NULL;
-  }
-
-  // Re-enable flicks for just a moment
-  base::win::EnableFlicks(hwnd);
-
-  delete this;
-}
-
-LegacyRenderWidgetHostHWND::LegacyRenderWidgetHostHWND(HWND parent)
+LegacyRenderWidgetHostHWND::LegacyRenderWidgetHostHWND(
+    HWND parent,
+    LegacyRenderWidgetHostHWNDDelegate* delegate)
     : mouse_tracking_enabled_(false),
-      host_(NULL) {
+      delegate_(delegate) {
+  DCHECK(delegate_);
   RECT rect = {0};
   Base::Create(parent, rect, L"Chrome Legacy Window",
                WS_CHILDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
                WS_EX_TRANSPARENT);
 }
 
-LegacyRenderWidgetHostHWND::~LegacyRenderWidgetHostHWND() {
-  DCHECK(!::IsWindow(hwnd()));
-}
-
 bool LegacyRenderWidgetHostHWND::Init() {
   if (base::win::GetVersion() >= base::win::VERSION_WIN7 &&
       ui::AreTouchEventsEnabled())
     RegisterTouchWindow(hwnd(), TWF_WANTPALM);
 
   HRESULT hr = ::CreateStdAccessibleObject(
       hwnd(), OBJID_WINDOW, IID_IAccessible,
       reinterpret_cast<void **>(window_accessible_.Receive()));
   DCHECK(SUCCEEDED(hr));
 
@@ skipping 37 matching lines @@
   // because it sometimes gets sign-extended incorrectly (but not always).
   DWORD obj_id = static_cast<DWORD>(static_cast<DWORD_PTR>(l_param));
 
   if (kIdScreenReaderHoneyPot == obj_id) {
     // When an MSAA client has responded to our fake event on this id,
     // enable screen reader support.
     BrowserAccessibilityState::GetInstance()->OnScreenReaderDetected();
     return static_cast<LRESULT>(0L);
   }
 
-  if (static_cast<DWORD>(OBJID_CLIENT) != obj_id || !host_)
+  if (static_cast<DWORD>(OBJID_CLIENT) != obj_id)
     return static_cast<LRESULT>(0L);
 
-  RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(
-      host_->GetRenderWidgetHost());
-  if (!rwhi)
+  base::win::ScopedComPtr<IAccessible> native_accessible(
+      delegate_->GetNativeViewAccessible());
+  if (!native_accessible)
     return static_cast<LRESULT>(0L);
 
-  BrowserAccessibilityManagerWin* manager =
-      static_cast<BrowserAccessibilityManagerWin*>(
-          rwhi->GetRootBrowserAccessibilityManager());
-  if (!manager)
-    return static_cast<LRESULT>(0L);
-
-  base::win::ScopedComPtr<IAccessible> root(
-      ToBrowserAccessibilityWin(manager->GetRoot()));
   return LresultFromObject(IID_IAccessible, w_param,
-      static_cast<IAccessible*>(root.Detach()));
+      static_cast<IAccessible*>(native_accessible.Detach()));
 }
 
 // We send keyboard/mouse/touch messages to the parent window via SendMessage.
 // While this works, this has the side effect of converting input messages into
 // sent messages which changes their priority and could technically result
 // in these messages starving other messages in the queue. Additionally
 // keyboard/mouse hooks would not see these messages. The alternative approach
 // is to set and release capture as needed on the parent to ensure that it
 // receives all mouse events. However that was shelved due to possible issues
 // with capture changes.
@@ skipping 207 matching lines @@
       direct_manipulation_helper_->Activate(hwnd());
     } else if (window_pos->flags & SWP_HIDEWINDOW) {
       direct_manipulation_helper_->Deactivate(hwnd());
     }
   }
   SetMsgHandled(FALSE);
   return 0;
 }
 
 }  // namespace content