Implement features in NativeViewHostAura for scroll end effect

ui/views/controls/native/native_view_host_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 "ui/views/controls/native/native_view_host_aura.h"
 
 #include "base/logging.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/window.h"
+#include "ui/gfx/safe_integer_conversions.h"
 #include "ui/views/controls/native/native_view_host.h"
 #include "ui/views/view_constants_aura.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
 NativeViewHostAura::NativeViewHostAura(NativeViewHost* host)
     : host_(host),
-      installed_clip_(false) {
+      installed_clip_(false),
+      clipping_window_(NULL) {
+    clipping_window_.SetTransparent(true);
+    clipping_window_.Init(ui::LAYER_NOT_DRAWN);
+    clipping_window_.set_owned_by_parent(false);
+    clipping_window_.layer()->set_name("NativeViewHostAuraClip");
+    clipping_window_.layer()->SetMasksToBounds(false);
 }
 
 NativeViewHostAura::~NativeViewHostAura() {
   if (host_->native_view()) {
     host_->native_view()->ClearProperty(views::kHostViewKey);
     host_->native_view()->RemoveObserver(this);
+    RemoveClippingWindow();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeViewHostAura, NativeViewHostWrapper implementation:
-void NativeViewHostAura::NativeViewWillAttach() {
+void NativeViewHostAura::AttachNativeView() {
   host_->native_view()->AddObserver(this);
   host_->native_view()->SetProperty(views::kHostViewKey,
       static_cast<View*>(host_));
+
+  AddClippingWindow();
 }
 
 void NativeViewHostAura::NativeViewDetaching(bool destroyed) {
+  RemoveClippingWindow();
   if (!destroyed) {
     host_->native_view()->ClearProperty(views::kHostViewKey);
     host_->native_view()->RemoveObserver(this);
     host_->native_view()->Hide();
+
     if (host_->native_view()->parent())
       Widget::ReparentNativeView(host_->native_view(), NULL);
   }
 }
 
 void NativeViewHostAura::AddedToWidget() {
   if (!host_->native_view())
     return;
 
-  aura::Window* widget_window = host_->GetWidget()->GetNativeView();
-  if (host_->native_view()->parent() != widget_window)
-    widget_window->AddChild(host_->native_view());
+  if (host_->native_view()->parent() !=
+      host_->GetWidget()->GetNativeView())

[sky, 2013/10/02 20:49:00]

nit: I think you can fit this on one line.

[rharrison, 2013/10/09 17:42:20]

Done.

+    AddClippingWindow();
+
   if (host_->IsDrawn())
     host_->native_view()->Show();
   else
     host_->native_view()->Hide();
   host_->Layout();
 }
 
 void NativeViewHostAura::RemovedFromWidget() {
   if (host_->native_view()) {
     host_->native_view()->Hide();
+    RemoveClippingWindow();

[sky, 2013/10/02 20:49:00]

Why do you need anything more than removing the clipping window from its parent
here?

[rharrison, 2013/10/09 17:42:20]

If we do that then the native will still be attached to the clipping window,
which means the existence of the clipping window will leak outside of the class
and leaves the native view's life time still tied to the NHVA, since the
clipping window, its parent, is tied to the NVHA.

[sky, 2013/10/09 20:21:37]

You're right. My question should be, can we just remove the clipping window and
keep the old code on old 63-64?

     if (host_->native_view()->parent())
       host_->native_view()->parent()->RemoveChild(host_->native_view());
   }
 }
 
 void NativeViewHostAura::InstallClip(int x, int y, int w, int h) {
-  // Note that this does not pose a problem functionality wise - it might
-  // however pose a speed degradation if not implemented.
-  LOG(WARNING) << "NativeViewHostAura::InstallClip is not implemented yet.";
+  gfx::Rect input_rect(x, y, w, h);

[xiyuan, 2013/10/02 20:47:29]

nit: seems not used.

[rharrison, 2013/10/09 17:42:20]

Done.

+
+  if (!installed_clip_) {

[sky, 2013/10/02 20:49:00]

nit: no {}

[rharrison, 2013/10/09 17:42:20]

Done.

+    orig_bounds_ = clipping_window_.layer()->bounds();

[xiyuan, 2013/10/02 20:47:29]

What if InstallClip is called while it has a clip? This could happen when we
SetBoundsRect on NativeViewHost during an animation. Should we cache the value
in ShowWidget call?

[rharrison, 2013/10/09 17:42:20]

Done.

+  }
+
+  installed_clip_ = true;
+
+  gfx::Rect clipping_bounds(x, y, w, h);
+  clipping_window_.layer()->SetMasksToBounds(true);
+  clipping_window_.layer()->SetBounds(clipping_bounds);

[xiyuan, 2013/10/02 20:47:29]

host_ calls InstallClip with (x,y) in its own cooridates (relative the the
origin of the hosted native view). Can we directly use it here?

[rharrison, 2013/10/09 17:42:20]

You are correct, I have fixed this.

+
+  gfx::Rect native_bounds = host_->native_view()->layer()->bounds();
+
+  gfx::Point native_origin = CalculateNativeViewOrigin(clipping_bounds,
+                                                       native_bounds);
+  native_bounds.set_origin(native_origin);
+  host_->native_view()->layer()->SetBounds(native_bounds);
 }
 
 bool NativeViewHostAura::HasInstalledClip() {
   return installed_clip_;
 }
 
 void NativeViewHostAura::UninstallClip() {
+  if (installed_clip_ == false)
+    return;
+
+  clipping_window_.layer()->SetMasksToBounds(false);
+  clipping_window_.layer()->SetBounds(orig_bounds_);

[sky, 2013/10/02 20:49:00]

ShowWidget is invoked right after this. Can you wait to set the bounds until
then?

[rharrison, 2013/10/09 17:42:20]

I think you meant InstallClip maybe? I want to avoid having the UninstallClip
method depend on a following call to InstallClip or other manipulations.
Basically UninstallClip should undo everything InstallClip does. I think the
UpdateClippingWindow from your version of the CL cleans this up nicely.

[sky, 2013/10/09 20:21:37]

Isn't there already this dependency though? NativeViewHost implementations can
assume a particular call order, otherwise things are going to break.

+  gfx::Rect layer_bounds = orig_bounds_;
+  layer_bounds.set_origin(gfx::Point(0,0));
+  host_->native_view()->layer()->SetBounds(layer_bounds);
+
   installed_clip_ = false;
 }
 
 void NativeViewHostAura::ShowWidget(int x, int y, int w, int h) {
-  // TODO: need to support fast resize.
-  host_->native_view()->SetBounds(gfx::Rect(x, y, w, h));
+  if (host_->fast_resize()) {

[xiyuan, 2013/10/02 20:47:29]

Is it possible to make it work for non fast resize path as well?

[rharrison, 2013/10/09 17:42:20]

The fast v. non-fast resize paths have semantic/functional differences.
Specificaly the fast path uses clipping, but never alerts the underlying native
view that a resize has happened, where as the regular resize path is going to be
updating the bounds of the native view. This has significant impact on how
something like blink behaves, so I don't think using clipping on the fast resize
path is appropriate or atleast out of the scope of this CL.

+    UninstallClip();
+    InstallClip(x, y, w, h);

[xiyuan, 2013/10/02 20:47:29]

ShowWidget's (x,y) is in host_->GetWidget()'s coordinates. And InstallClip
expect something relative to host_->native_view(). Think we need translation
here.

[rharrison, 2013/10/09 17:42:20]

I agree, Done.

+  } else {
+    clipping_window_.SetBounds(gfx::Rect(x, y, w, h));
+    host_->native_view()->SetBounds(gfx::Rect(0, 0, w, h));
+  }
   host_->native_view()->Show();
 }
 
 void NativeViewHostAura::HideWidget() {
   host_->native_view()->Hide();
 }
 
 void NativeViewHostAura::SetFocus() {
   aura::Window* window = host_->native_view();
   aura::client::FocusClient* client = aura::client::GetFocusClient(window);
   if (client)
     client->FocusWindow(window);
 }
 
 gfx::NativeViewAccessible NativeViewHostAura::GetNativeViewAccessible() {
   return NULL;
 }
 
 void NativeViewHostAura::OnWindowDestroyed(aura::Window* window) {
-  DCHECK(window == host_->native_view());
-  host_->NativeViewDestroyed();
+  if (window == host_->native_view())

[sky, 2013/10/02 20:49:00]

Why the if and not the DCHECK? This only adds one observer.

[rharrison, 2013/10/09 17:42:20]

Done.

+    host_->NativeViewDestroyed();
+
 }
 
 // static
 NativeViewHostWrapper* NativeViewHostWrapper::CreateWrapper(
     NativeViewHost* host) {
   return new NativeViewHostAura(host);
 }
 
+gfx::Point NativeViewHostAura::CalculateNativeViewOrigin(
+    const gfx::Rect& input_rect,
+    const gfx::Rect& native_rect) const {
+  int new_x = gfx::ToRoundedInt(host_->GetWidthScaleFactor() *
+                                (input_rect.width() -
+                                 native_rect.width()));
+  int new_y = gfx::ToRoundedInt(host_->GetHeightScaleFactor() *
+                                (input_rect.height() -
+                                 native_rect.height()));
+  return gfx::Point(new_x, new_y);
+}
+
+void NativeViewHostAura::AddClippingWindow() {
+  gfx::Rect bounds = host_->native_view()->bounds();
+
+  if (host_->GetWidget()->GetNativeView())
+    Widget::ReparentNativeView(&clipping_window_,
+                               host_->GetWidget()->GetNativeView());
+  Widget::ReparentNativeView(host_->native_view(),
+                             &clipping_window_);
+
+  clipping_window_.SetBounds(bounds);
+  bounds.set_origin(gfx::Point(0,0));
+  host_->native_view()->SetBounds(bounds);
+
+  clipping_window_.Show();
+}
+
+void NativeViewHostAura::RemoveClippingWindow() {
+  if (host_->native_view()->parent() == &clipping_window_) {
+    if (host_->GetWidget()->GetNativeView()) {
+      Widget::ReparentNativeView(host_->native_view(),
+                                 host_->GetWidget()->GetNativeView());
+    } else {
+      clipping_window_.RemoveChild(host_->native_view());
+    }
+
+    clipping_window_.Hide();
+    host_->native_view()->SetBounds(clipping_window_.bounds());
+    if (clipping_window_.parent())
+      clipping_window_.parent()->RemoveChild(&clipping_window_);
+  }
+}
+
 }  // namespace views