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) {
 }
 
 NativeViewHostAura::~NativeViewHostAura() {
   if (host_->native_view()) {
     host_->native_view()->ClearProperty(views::kHostViewKey);
     host_->native_view()->RemoveObserver(this);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeViewHostAura, NativeViewHostWrapper implementation:
-void NativeViewHostAura::NativeViewWillAttach() {
+void NativeViewHostAura::AttachNativeView() {
   host_->native_view()->AddObserver(this);
   host_->native_view()->SetProperty(views::kHostViewKey,
       static_cast<View*>(host_));
+
+  Widget::ReparentNativeView(host_->native_view(),

[sky, 2013/10/01 15:06:43]

Can't this be done using the clipping layer as the new parent and after
AddclippingWindow?

[rharrison, 2013/10/02 19:02:50]

I have moved all of the reparenting down into AddClippingWindow.
Done

+                             host_->GetWidget()->GetNativeView());
+
+  Widget* widget = Widget::GetWidgetForNativeView(host_->native_view());

[sky, 2013/10/01 15:06:43]

Can these three lines be kept in NativeViewHost?

[rharrison, 2013/10/02 19:02:50]

Done.

+  if (widget)
+    widget->SetNativeWindowProperty(kWidgetNativeViewHostKey, host_);
+  AddClippingWindow();
+  host_->Layout();

[sky, 2013/10/01 15:06:43]

How come Layout is invoked at the end here, but not in NativeViewHostWin?

[rharrison, 2013/10/02 19:02:50]

I most likely moved it to the end, since the layout should be call after all of
the hiearchy changes, but forgot to move it in _win. I will make sure they
match.

Done.

 }
 
 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());
+    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();
     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);
+
+  if (!installed_clip_) {
+    orig_bounds_ = clipping_window_->layer()->bounds();
+  }
+
+  installed_clip_ = true;
+
+  gfx::Rect clipping_bounds(x, y, w, h);
+  clipping_window_->layer()->SetMasksToBounds(true);
+  clipping_window_->layer()->SetBounds(clipping_bounds);
+
+  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_);
+  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()) {
+    UninstallClip();
+    InstallClip(x, y, w, h);
+  } 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())
+    host_->NativeViewDestroyed();
+  if (window == clipping_window_)

[sky, 2013/10/01 15:06:43]

How will this ever happen since you don't add this as an observer of
clipping_window_?

I'm still worried that ownership isn't quite right here. What happens if
clipping_window_ is deleted out from under you? Does the code deal with that?
How about a test? This case could likely happen if someone deletes a Widget that
contains a NativeViewHost.

[rharrison, 2013/10/02 19:02:50]

I have written the clipping_window_ ownership code again. Specifically it is a
member of NVHA, but owned_by_parent is being set to false, so that its life time
is tied to the NVHA, instead of their being contention with the hierarchy owning
it.

I think the ownership has been significantly simplified by doing this, but I
have added a test that creates a widget and attaches a host to it. The widget is
then deleted and it is confirmed that the host is deleted also. There is an
implicit condition in the test that it completes that confirms nothing really
bad is occurring in this case.

+    clipping_window_ = NULL;
 }
 
 // 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() {
+  if (!clipping_window_) {
+    clipping_window_ = new aura::Window(NULL);
+    clipping_window_->SetTransparent(true);
+    clipping_window_->Init(ui::LAYER_NOT_DRAWN);
+    clipping_window_->layer()->set_name("NativeViewHostAuraClip");
+    clipping_window_->layer()->SetMasksToBounds(false);
+  }
+
+  aura::Window* widget_window = host_->GetWidget()->GetNativeView();
+  widget_window->AddChild(clipping_window_);
+  clipping_window_->AddChild(host_->native_view());
+
+  gfx::Rect bounds = host_->native_view()->bounds();
+  bounds.set_origin(gfx::Point(0,0));
+  host_->native_view()->SetBounds(bounds);
+
+  clipping_window_->Show();
+  host_->Layout();
+}
+
+void NativeViewHostAura::RemoveClippingWindow() {
+  if (host_->native_view()->parent() == clipping_window_ &&
+      clipping_window_ != NULL) {
+    clipping_window_->parent()->AddChild(host_->native_view());
+    clipping_window_->parent()->RemoveChild(clipping_window_);
+    host_->native_view()->SetBounds(clipping_window_->bounds());
+    clipping_window_->Hide();
+    delete clipping_window_;
+    clipping_window_ = NULL;
+  }
+}
+
 }  // namespace views