Re-implement overscan & Implement Display Rotation

ui/aura/root_window.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/root_window.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 101 matching lines @@
       event_dispatch_target_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       defer_draw_scheduling_(false),
       mouse_move_hold_count_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(held_mouse_event_factory_(this)) {
   SetName("RootWindow");
+  host_->SetInsets(params.initial_insets);
 
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
 
   prop_.reset(new ui::ViewProp(host_->GetAcceleratedWidget(),
                                kRootWindowForAcceleratedWidget,
                                this));
 }
 
@@ skipping 15 matching lines @@
     gfx::AcceleratedWidget widget) {
   return reinterpret_cast<RootWindow*>(
       ui::ViewProp::GetValue(widget, kRootWindowForAcceleratedWidget));
 }
 
 void RootWindow::Init() {
   compositor()->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(this),
                                 host_->GetBounds().size());
   Window::Init(ui::LAYER_NOT_DRAWN);
   compositor()->SetRootLayer(layer());
-  SetBounds(
-      ui::ConvertRectToDIP(layer(), gfx::Rect(host_->GetBounds().size())));
+  SetTransformInternal(gfx::Transform());
+  UpdateWindowSize(host_->GetBounds().size());
   Env::GetInstance()->NotifyRootWindowInitialized(this);
   Show();
 }
 
 void RootWindow::ShowRootWindow() {
   host_->Show();
 }
 
 void RootWindow::HideRootWindow() {
   host_->Hide();
@@ skipping 21 matching lines @@
     SetLastMouseLocation(this, ui::ConvertPointToDIP(layer(), point));
 
   synthesize_mouse_move_ = false;
 }
 
 gfx::Size RootWindow::GetHostSize() const {
   return host_->GetBounds().size();
 }
 
 void RootWindow::SetHostBounds(const gfx::Rect& bounds_in_pixel) {
+  SetHostBoundsAndInsets(bounds_in_pixel, gfx::Insets());
+}
+
+void RootWindow::SetHostBoundsAndInsets(const gfx::Rect& bounds_in_pixel,
+                                        const gfx::Insets& insets_in_pixel) {
   DCHECK(!bounds_in_pixel.IsEmpty());
   DispatchHeldMouseMove();
+  host_->SetInsets(insets_in_pixel);
   host_->SetBounds(bounds_in_pixel);
   synthesize_mouse_move_ = false;
 }
 
 gfx::Point RootWindow::GetHostOrigin() const {
   return host_->GetBounds().origin();
 }
 
 void RootWindow::SetCursor(gfx::NativeCursor cursor) {
   last_cursor_ = cursor;
@@ skipping 224 matching lines @@
 
 RootWindow* RootWindow::GetRootWindow() {
   return this;
 }
 
 const RootWindow* RootWindow::GetRootWindow() const {
   return this;
 }
 
 void RootWindow::SetTransform(const gfx::Transform& transform) {
-  Window::SetTransform(transform);
+  SetTransformInternal(transform);
 
   // If the layer is not animating, then we need to update the host size
   // immediately.
   if (!layer()->GetAnimator()->is_animating())
     OnHostResized(host_->GetBounds().size());
 }
 
+void RootWindow::SetTransformInternal(const gfx::Transform& transform) {
+  gfx::Transform t;
+  gfx::Insets insets = host_->GetInsets();
+  if (insets.top() != 0 || insets.left() != 0) {
+    float device_scale_factor = GetDeviceScaleFactor();
+    t.Translate(insets.left() / device_scale_factor,
+                insets.top() / device_scale_factor);
+  }
+  Window::SetTransform(t * transform);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::EventTarget implementation:
 
 ui::EventTarget* RootWindow::GetParentTarget() {
   return client::GetEventClient(this) ?
       client::GetEventClient(this)->GetToplevelEventTarget() :
           Env::GetInstance();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 251 matching lines @@
 void RootWindow::CleanupGestureRecognizerState(Window* window) {
   gesture_recognizer_->CleanupStateForConsumer(window);
   Windows windows = window->children();
   for (Windows::const_iterator iter = windows.begin();
       iter != windows.end();
       ++iter) {
     CleanupGestureRecognizerState(*iter);
   }
 }
 
+void RootWindow::UpdateWindowSize(const gfx::Size& host_size) {
+  gfx::Rect bounds(host_size);
+  bounds.Inset(host_->GetInsets());
+  bounds = ui::ConvertRectToDIP(layer(), bounds);
+  gfx::RectF new_bounds(bounds);
+  layer()->transform().TransformRect(&new_bounds);
+  // Ignore the origin because RootWindow's insets are handled by
+  // the transform.
+  SetBounds(gfx::Rect(gfx::ToNearestRect(new_bounds).size()));
+}
+
 void RootWindow::OnWindowAddedToRootWindow(Window* attached) {
   if (attached->IsVisible() &&
       attached->ContainsPointInRoot(GetLastMouseLocationInRoot()))
     PostMouseMoveEventAfterWindowChange();
 }
 
 bool RootWindow::CanDispatchToTarget(ui::EventTarget* target) {
   return event_dispatch_target_ == target;
 }
 
@@ skipping 182 matching lines @@
 
 void RootWindow::OnHostResized(const gfx::Size& size) {
   DispatchHeldMouseMove();
   // The compositor should have the same size as the native root window host.
   // Get the latest scale from display because it might have been changed.
   compositor_->SetScaleAndSize(GetDeviceScaleFactorFromDisplay(this), size);
 
   // The layer, and all the observers should be notified of the
   // transformed size of the root window.
   gfx::Size old(bounds().size());
-  gfx::RectF bounds(ui::ConvertSizeToDIP(layer(), size));
-  layer()->transform().TransformRect(&bounds);
-  // The transform is expected to produce an integer rect as its output.
-  SetBounds(gfx::ToNearestRect(bounds));
+  UpdateWindowSize(size);
+  // TODO(oshima): Rename this to OnHostWindowResized.
   FOR_EACH_OBSERVER(RootWindowObserver, observers_,
                     OnRootWindowResized(this, old));
 }
 
 float RootWindow::GetDeviceScaleFactor() {
   return compositor()->device_scale_factor();
 }
 
 RootWindow* RootWindow::AsRootWindow() {
   return this;
@@ skipping 98 matching lines @@
   // currently broken. See/ crbug.com/107931.
   ui::MouseEvent event(ui::ET_MOUSE_MOVED,
                        orig_mouse_location,
                        orig_mouse_location,
                        ui::EF_IS_SYNTHESIZED);
   event.set_system_location(Env::GetInstance()->last_mouse_location());
   OnHostMouseEvent(&event);
 }
 
 }  // namespace aura