Correctly update the popup window position

content/browser/renderer_host/render_widget_host_view_aura_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <tuple>
@@ skipping 412 matching lines @@
   void ReturnResources(const cc::ReturnedResourceArray& resources) {
     GetDelegatedFrameHost()->ReturnResources(resources);
   }
 
   void ResetCompositor() { GetDelegatedFrameHost()->ResetCompositor(); }
 
   const ui::MotionEventAura& pointer_state_for_test() {
     return event_handler()->pointer_state();
   }
 
+  // In this unit test, |window_| is directly added to the root and is
+  // toplevel.
+  aura::Window* GetToplevelWindow() override { return window(); }
+
   gfx::Size last_frame_size_;
   std::unique_ptr<cc::CopyOutputRequest> last_copy_request_;
   FakeWindowEventDispatcher* dispatcher_;
 
  private:
   FakeDelegatedFrameHostClientAura* delegated_frame_host_client_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeRenderWidgetHostViewAura);
 };
 
@@ skipping 67 matching lines @@
 
 const WebInputEvent* GetInputEventFromMessage(const IPC::Message& message) {
   base::PickleIterator iter(message);
   const char* data;
   int data_length;
   if (!iter.ReadData(&data, &data_length))
     return nullptr;
   return reinterpret_cast<const WebInputEvent*>(data);
 }
 
+class MockRenderWidgetHostViewAura : public RenderWidgetHostViewAura {
+ public:
+  MockRenderWidgetHostViewAura(RenderWidgetHost* host, bool is_guest_view_hack)
+      : RenderWidgetHostViewAura(host, is_guest_view_hack) {}
+
+  ~MockRenderWidgetHostViewAura() override {}
+
+ protected:
+  aura::Window* GetToplevelWindow() override { return window(); }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockRenderWidgetHostViewAura);
+};
+
 }  // namespace
 
 class RenderWidgetHostViewAuraTest : public testing::Test {
  public:
   RenderWidgetHostViewAuraTest()
       : widget_host_uses_shutdown_to_destroy_(false),
         is_guest_view_hack_(false) {}
 
   static void InstallDelegatedFrameHostClient(
       RenderWidgetHostViewAura* render_widget_host_view,
       std::unique_ptr<DelegatedFrameHostClient> delegated_frame_host_client) {
     render_widget_host_view->delegated_frame_host_client_ =
         std::move(delegated_frame_host_client);
   }
 
   void SetUpEnvironment() {
     ImageTransportFactory::InitializeForUnitTests(
         std::unique_ptr<ImageTransportFactory>(
             new NoTransportImageTransportFactory));
     aura_test_helper_.reset(
         new aura::test::AuraTestHelper(base::MessageLoopForUI::current()));
     aura_test_helper_->SetUp(
         ImageTransportFactory::GetInstance()->GetContextFactory(),
         ImageTransportFactory::GetInstance()->GetContextFactoryPrivate());
     new wm::DefaultActivationClient(aura_test_helper_->root_window());
+    aura::client::SetScreenPositionClient(aura_test_helper_->root_window(),
+                                          &screen_position_client_);
 
     browser_context_.reset(new TestBrowserContext);
     process_host_ = new MockRenderProcessHost(browser_context_.get());
     process_host_->Init();
 
     sink_ = &process_host_->sink();
 
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     parent_host_ = new RenderWidgetHostImpl(delegates_.back().get(),
                                             process_host_, routing_id, false);
     delegates_.back()->set_widget_host(parent_host_);
-    parent_view_ = new RenderWidgetHostViewAura(parent_host_,
-                                                is_guest_view_hack_);
+    parent_view_ =
+        new MockRenderWidgetHostViewAura(parent_host_, is_guest_view_hack_);
     parent_view_->InitAsChild(nullptr);
     aura::client::ParentWindowWithContext(parent_view_->GetNativeView(),
                                           aura_test_helper_->root_window(),
                                           gfx::Rect());
 
     routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     widget_host_ = new MockRenderWidgetHostImpl(delegates_.back().get(),
                                                 process_host_, routing_id);
     delegates_.back()->set_widget_host(widget_host_);
@@ skipping 137 matching lines @@
 
   // If true, then calls RWH::Shutdown() instead of deleting RWH.
   bool widget_host_uses_shutdown_to_destroy_;
 
   bool is_guest_view_hack_;
 
   TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<aura::test::AuraTestHelper> aura_test_helper_;
   std::unique_ptr<BrowserContext> browser_context_;
   std::vector<std::unique_ptr<MockRenderWidgetHostDelegate>> delegates_;
+  wm::DefaultScreenPositionClient screen_position_client_;
   MockRenderProcessHost* process_host_;
 
   // Tests should set these to nullptr if they've already triggered their
   // destruction.
   RenderWidgetHostImpl* parent_host_;
   RenderWidgetHostViewAura* parent_view_;
 
   // Tests should set these to nullptr if they've already triggered their
   // destruction.
   MockRenderWidgetHostImpl* widget_host_;
@@ skipping 269 matching lines @@
   EXPECT_TRUE(window->HasFocus());
 
   // Check that we'll also say it's okay to activate the window when there's an
   // ActivationClient defined.
   EXPECT_TRUE(view_->ShouldActivate());
 }
 
 // Checks that a popup is positioned correctly relative to its parent using
 // screen coordinates.
 TEST_F(RenderWidgetHostViewAuraTest, PositionChildPopup) {
-  wm::DefaultScreenPositionClient screen_position_client;
 
   aura::Window* window = parent_view_->GetNativeView();
   aura::Window* root = window->GetRootWindow();
-  aura::client::SetScreenPositionClient(root, &screen_position_client);
 
   parent_view_->SetBounds(gfx::Rect(10, 10, 800, 600));
   gfx::Rect bounds_in_screen = parent_view_->GetViewBounds();
   int horiz = bounds_in_screen.width() / 4;
   int vert = bounds_in_screen.height() / 4;
   bounds_in_screen.Inset(horiz, vert);
 
   // Verify that when the popup is initialized for the first time, it correctly
   // treats the input bounds as screen coordinates.
   view_->InitAsPopup(parent_view_, bounds_in_screen);
@@ skipping 3173 matching lines @@
       : view_(nullptr) {}
    ~RenderWidgetHostViewAuraWithViewHarnessTest() override {}
 
  protected:
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
     // Delete the current RenderWidgetHostView instance before setting
     // the RWHVA as the view.
     delete contents()->GetRenderViewHost()->GetWidget()->GetView();
     // This instance is destroyed in the TearDown method below.
-    view_ = new RenderWidgetHostViewAura(
-        contents()->GetRenderViewHost()->GetWidget(),
-        false);
+    view_ = new MockRenderWidgetHostViewAura(
+        contents()->GetRenderViewHost()->GetWidget(), false);
   }
 
   void TearDown() override {
     view_->Destroy();
     RenderViewHostImplTestHarness::TearDown();
   }
 
   RenderWidgetHostViewAura* view() {
     return view_;
   }
@@ skipping 510 matching lines @@
 
     // Retrieve the selected text from clipboard and verify it is as expected.
     base::string16 result_text;
     clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &result_text);
     EXPECT_EQ(expected_text, result_text);
   }
 }
 #endif
 
 }  // namespace content