SetDeviceScaleFactorForTest

ui/aura/test/test_screen.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 "ui/aura/test/test_screen.h"
 
 #include <stdint.h>
 
+#include <vector>
+
 #include "base/logging.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/native_widget_types.h"
@@ skipping 13 matching lines @@
 TestScreen* TestScreen::Create(const gfx::Size& size) {
   const gfx::Size kDefaultSize(800, 600);
   // Use (0,0) because the desktop aura tests are executed in
   // native environment where the display's origin is (0,0).
   return new TestScreen(gfx::Rect(size.IsEmpty() ? kDefaultSize : size));
 }
 
 TestScreen::~TestScreen() {
 }
 
-WindowTreeHost* TestScreen::CreateHostForPrimaryDisplay() {
-  DCHECK(!host_);
-  host_ = WindowTreeHost::Create(gfx::Rect(display_.GetSizeInPixel()));
+void TestScreen::CreateHostForPrimaryDisplay() {
+  DCHECK(!host_.get());
+  host_.reset(WindowTreeHost::Create(gfx::Rect(display_.GetSizeInPixel())));
   // Some tests don't correctly manage window focus/activation states.
   // Makes sure InputMethod is default focused so that IME basics can work.
   host_->GetInputMethod()->OnFocus();
   host_->window()->AddObserver(this);
   host_->InitHost();
-  return host_;
-}
-
-void TestScreen::SetDeviceScaleFactor(float device_scale_factor) {
-  gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
-  display_.SetScaleAndBounds(device_scale_factor, bounds_in_pixel);
-  host_->OnHostResized(bounds_in_pixel.size());
 }
 
 void TestScreen::SetDisplayRotation(display::Display::Rotation rotation) {
   gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
   gfx::Rect new_bounds(bounds_in_pixel);
   if (IsRotationPortrait(rotation) != IsRotationPortrait(display_.rotation())) {
     new_bounds.set_width(bounds_in_pixel.height());
     new_bounds.set_height(bounds_in_pixel.width());
   }
   display_.set_rotation(rotation);
@@ skipping 47 matching lines @@
   return ui_scale;
 }
 
 void TestScreen::OnWindowBoundsChanged(
     Window* window, const gfx::Rect& old_bounds, const gfx::Rect& new_bounds) {
   DCHECK_EQ(host_->window(), window);
   display_.SetSize(gfx::ScaleToFlooredSize(new_bounds.size(),
                                            display_.device_scale_factor()));
 }
 
-void TestScreen::OnWindowDestroying(Window* window) {
-  if (host_->window() == window)
-    host_ = NULL;
-}
-
 gfx::Point TestScreen::GetCursorScreenPoint() {
   return Env::GetInstance()->last_mouse_location();
 }
 
 bool TestScreen::IsWindowUnderCursor(gfx::NativeWindow window) {
   return GetWindowAtScreenPoint(GetCursorScreenPoint()) == window;
 }
 
 gfx::NativeWindow TestScreen::GetWindowAtScreenPoint(const gfx::Point& point) {
   if (!host_ || !host_->window())
@@ skipping 17 matching lines @@
 display::Display TestScreen::GetDisplayNearestPoint(
     const gfx::Point& point) const {
   return display_;
 }
 
 display::Display TestScreen::GetDisplayMatching(
     const gfx::Rect& match_rect) const {
   return display_;
 }
 
-void TestScreen::AddObserver(display::DisplayObserver* observer) {}
+void TestScreen::AddObserver(display::DisplayObserver* observer) {
+  notifier_.AddObserver(observer);
+}
 
-void TestScreen::RemoveObserver(display::DisplayObserver* observer) {}
+void TestScreen::RemoveObserver(display::DisplayObserver* observer) {
+  notifier_.RemoveObserver(observer);
+}
+
+void TestScreen::SetDeviceScaleFactorForTest(float device_scale_factor) {
+  gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
+
+  std::vector<display::Display> old_displays;
+  old_displays.push_back(display_);
+  display_.SetScaleAndBounds(device_scale_factor, bounds_in_pixel);
+  std::vector<display::Display> new_displays;
+  new_displays.push_back(display_);
+  LOG(ERROR) << "Calling On Host Resized: display=" << display_.ToString();
+  host_->OnHostResized(bounds_in_pixel.size());
+  LOG(ERROR) << "Calling On Host Resized: Done";
+  notifier_.NotifyDisplaysChanged(old_displays, new_displays);
+}
 
 TestScreen::TestScreen(const gfx::Rect& screen_bounds)
-    : host_(NULL),
-      ui_scale_(1.0f) {
+    : ui_scale_(1.0f) {
   static int64_t synthesized_display_id = 2000;
   display_.set_id(synthesized_display_id++);
   display_.SetScaleAndBounds(1.0f, screen_bounds);
 }
 
 }  // namespace aura