Draw omnibox shadow with a ninebox layer.

chrome/browser/ui/views/omnibox/omnibox_popup_contents_view.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 "chrome/browser/ui/views/omnibox/omnibox_popup_contents_view.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "chrome/browser/ui/views/omnibox/omnibox_result_view.h"
 #include "chrome/browser/ui/views/theme_copying_widget.h"
 #include "components/omnibox/browser/omnibox_view.h"
 #include "third_party/skia/include/core/SkDrawLooper.h"
 #include "ui/base/theme_provider.h"
 #include "ui/compositor/clip_recorder.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
+#include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/view_targeter.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
+#include "base/json/json_string_value_serializer.h"
+#include "cc/debug/micro_benchmark_controller.h"
+#include "cc/raster/one_copy_raster_buffer_provider.h"
+#include "cc/trees/layer_tree_host.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
+#include "ui/events/base_event_utils.h"
+
 namespace {
 
-// Cache the shadow images so that potentially expensive shadow drawing isn't
+namespace test {
+
+class Experiment : public ui::CompositorAnimationObserver {
+ public:
+  explicit Experiment(views::View* tabstrip) : tabstrip_(tabstrip) {
+    CHECK(tabstrip_->GetWidget());
+    compositor_ = tabstrip_->GetWidget()->GetCompositor();
+    compositor_->AddAnimationObserver(this);
+   // views::View::ConvertPointToWidget(tabstrip_, &start_);
+   // start_.set_y(start_.y() + tabstrip_->height() / 2);
+
+    CHECK_GT(compositor_->layer_tree_host()->ScheduleMicroBenchmark(
+        "rasterize_and_record_benchmark",
+        base::MakeUnique<base::DictionaryValue>(),
+        base::Bind(&Experiment::BenchmarkDone, base::Unretained(this))), 0);
+ //   cc::RasterStats::SetInstance(&stats_);
+  }
+
+ private:
+  ~Experiment() override {
+    if (compositor_)
+      compositor_->RemoveAnimationObserver(this);
+  }
+
+  void BenchmarkDone(std::unique_ptr<base::Value> value) {
+    std::string str;
+    JSONStringValueSerializer ser(&str);
+    ser.Serialize(*value);
+    LOG(ERROR) << str;
+  }
+
+  // ui::CompositorAnimationObserver:
+  void OnAnimationStep(base::TimeTicks timestamp) override {
+#if 0
+    gfx::Point location = start_;
+    location.set_x(location.x() + x_);
+
+    if (inc_) {
+      ++x_;
+      if (x_ >= tabstrip_->max_x()) {
+        --x_;
+        inc_ = false;
+        ++round_trips_;
+      }
+    } else {
+      --x_;
+      if (x_ < 0) {
+        ++x_;
+        inc_ = true;
+        ++round_trips_;
+      }
+    }
+
+    CHECK_GT(compositor_->layer_tree_host()->ScheduleMicroBenchmark(
+        "rasterize_and_record_benchmark",
+        base::MakeUnique<base::DictionaryValue>(),
+        base::Bind(&Experiment::BenchmarkDone, base::Unretained(this))), 0);
+    ui::MouseEvent move(ui::ET_MOUSE_MOVED, location, location,
+                        ui::EventTimeForNow(),
+                        ui::EF_NONE, ui::EF_NONE);
+    tabstrip_->GetWidget()->GetNativeWindow()->delegate()->OnMouseEvent(&move);
+    if (round_trips_ >= 2) {
+      LOG(ERROR) << "DONE ====================================================";
+      LOG(ERROR) << "Total: " << stats_.bytes();
+      compositor_->RemoveAnimationObserver(this);
+      compositor_ = nullptr;
+      cc::RasterStats::SetInstance(nullptr);
+   }
+#endif
+  }
+
+  void OnCompositingShuttingDown(ui::Compositor* compositor) override {
+    CHECK_EQ(compositor_, compositor);
+    compositor_ = nullptr;
+  }
+
+  views::View* tabstrip_;
+  ui::Compositor* compositor_ = nullptr;
+ // gfx::Point start_;
+ // int x_ = 0;
+ // bool inc_ =  true;
+ // int round_trips_ = 0;
+ // cc::RasterStats stats_;
+
+  DISALLOW_COPY_AND_ASSIGN(Experiment);
+};
+
+}  // test
+
+// This source takes two images and draws one above the other.
+class StackedImagesImageSource : public gfx::CanvasImageSource {
+ public:
+  StackedImagesImageSource(const gfx::ImageSkia& top,
+                           const gfx::ImageSkia& bottom)
+      : CanvasImageSource(
+            gfx::Size(top.width(), top.height() + bottom.height()),
+            false),
+        top_(top),
+        bottom_(bottom) {
+    DCHECK_EQ(top.width(), bottom.width());
+  }
+  ~StackedImagesImageSource() override {}
+
+  // CanvasImageSource overrides:
+  void Draw(gfx::Canvas* canvas) override {
+    canvas->DrawImageInt(top_, 0, 0);
+    canvas->DrawImageInt(bottom_, 0, top_.height());
+  }
+
+ private:
+  const gfx::ImageSkia top_;
+  const gfx::ImageSkia bottom_;
+
+  DISALLOW_COPY_AND_ASSIGN(StackedImagesImageSource);
+};
+
+// Cache the shadow image so that potentially expensive shadow drawing isn't
 // repeated.
-base::LazyInstance<gfx::ImageSkia> g_top_shadow = LAZY_INSTANCE_INITIALIZER;
-base::LazyInstance<gfx::ImageSkia> g_bottom_shadow = LAZY_INSTANCE_INITIALIZER;
+static int g_top_shadow_height = 0;
+static int g_bottom_shadow_height = 0;
+base::LazyInstance<gfx::ImageSkia> g_shadow_ninebox = LAZY_INSTANCE_INITIALIZER;
 
 const int kPopupVerticalPadding = 4;
 
 }  // namespace
 
 class OmniboxPopupContentsView::AutocompletePopupWidget
     : public ThemeCopyingWidget,
       public base::SupportsWeakPtr<AutocompletePopupWidget> {
  public:
   explicit AutocompletePopupWidget(views::Widget* role_model)
@@ skipping 28 matching lines @@
       omnibox_view_(omnibox_view),
       location_bar_view_(location_bar_view),
       font_list_(font_list),
       ignore_mouse_drag_(false),
       size_animation_(this),
       start_margin_(0),
       end_margin_(0) {
   // The contents is owned by the LocationBarView.
   set_owned_by_client();
 
-  if (g_top_shadow.Get().isNull()) {
-    std::vector<gfx::ShadowValue> shadows;
+  if (g_shadow_ninebox.Get().isNull()) {
+    std::vector<gfx::ShadowValue> top_shadows;
     // Blur by 1dp. See comment below about blur accounting.
-    shadows.emplace_back(gfx::Vector2d(), 2, SK_ColorBLACK);
-    g_top_shadow.Get() =
-        gfx::ImageSkiaOperations::CreateHorizontalShadow(shadows, false);
-  }
-  if (g_bottom_shadow.Get().isNull()) {
+    top_shadows.emplace_back(gfx::Vector2d(), 2, SK_ColorBLACK);
+    gfx::ImageSkia top_shadow_image =
+        gfx::ImageSkiaOperations::CreateHorizontalShadow(top_shadows, false);
+    g_top_shadow_height = top_shadow_image.height();
+
+    // Values for the bottom shadow.
     const int kSmallShadowBlur = 3;
     const int kLargeShadowBlur = 8;
     const int kLargeShadowYOffset = 3;
 
-    std::vector<gfx::ShadowValue> shadows;
+    std::vector<gfx::ShadowValue> bottom_shadows;
     // gfx::ShadowValue counts blur pixels both inside and outside the shape,
     // whereas these blur values only describe the outside portion, hence they
     // must be doubled.
-    shadows.emplace_back(gfx::Vector2d(), 2 * kSmallShadowBlur,
-                         SK_ColorBLACK);
-    shadows.emplace_back(gfx::Vector2d(0, kLargeShadowYOffset),
-                         2 * kLargeShadowBlur, SK_ColorBLACK);
+    bottom_shadows.emplace_back(gfx::Vector2d(), 2 * kSmallShadowBlur,
+                                SK_ColorBLACK);
+    bottom_shadows.emplace_back(gfx::Vector2d(0, kLargeShadowYOffset),
+                                2 * kLargeShadowBlur, SK_ColorBLACK);
 
-    g_bottom_shadow.Get() =
-        gfx::ImageSkiaOperations::CreateHorizontalShadow(shadows, true);
+    gfx::ImageSkia bottom_shadow_image =
+        gfx::ImageSkiaOperations::CreateHorizontalShadow(bottom_shadows, true);
+    g_bottom_shadow_height = bottom_shadow_image.height();
+    auto source =
+        new StackedImagesImageSource(top_shadow_image, bottom_shadow_image);
+    g_shadow_ninebox.Get() = gfx::ImageSkia(source, source->size());
   }
+  shadow_layer_.reset(new ui::Layer(ui::LAYER_NINE_PATCH));
+  shadow_layer_->SetFillsBoundsOpaquely(false);
+  shadow_layer_->UpdateNinePatchLayerImage(g_shadow_ninebox.Get());
+  shadow_layer_->UpdateNinePatchLayerAperture(
+      gfx::Rect(0, g_top_shadow_height, 1, 0));
+  shadow_layer_->UpdateNinePatchLayerBorder(gfx::Rect(
+      0, g_top_shadow_height, 0, g_top_shadow_height + g_bottom_shadow_height));
 
   SetEventTargeter(
       std::unique_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
 }
 
+void OmniboxPopupContentsView::ViewHierarchyChanged(
+    const ViewHierarchyChangedDetails& details) {
+  if (experiment_started_)
+    return;
+  if (!GetWidget())
+    return;
+  new test::Experiment(this);
+  experiment_started_ = true;
+}
+
 void OmniboxPopupContentsView::Init() {
   // This can't be done in the constructor as at that point we aren't
   // necessarily our final class yet, and we may have subclasses
   // overriding CreateResultView.
   for (size_t i = 0; i < AutocompleteResult::kMaxMatches; ++i) {
     OmniboxResultView* result_view = CreateResultView(i, font_list_);
     result_view->SetVisible(false);
     AddChildViewAt(result_view, static_cast<int>(i));
   }
 }
@@ skipping 16 matching lines @@
   int current_height_delta = static_cast<int>(
       size_animation_.GetCurrentValue() * total_height_delta - 0.5);
   current_frame_bounds.set_height(
       current_frame_bounds.height() + current_height_delta);
   return current_frame_bounds;
 }
 
 void OmniboxPopupContentsView::LayoutChildren() {
   gfx::Rect contents_rect = GetContentsBounds();
   contents_rect.Inset(gfx::Insets(kPopupVerticalPadding, 0));
-  contents_rect.Inset(start_margin_, g_top_shadow.Get().height(), end_margin_,
+  contents_rect.Inset(start_margin_, 0, end_margin_,
                       0);
 
   int top = contents_rect.y();
   for (size_t i = 0; i < AutocompleteResult::kMaxMatches; ++i) {
     View* v = child_at(i);
     if (v->visible()) {
       v->SetBounds(contents_rect.x(), top, contents_rect.width(),
                    v->GetPreferredSize().height());
       top = v->bounds().bottom();
     }
@@ skipping 57 matching lines @@
           max_match_contents_width_, view->GetMatchContentsWidth());
     }
   }
 
   for (size_t i = result_size; i < AutocompleteResult::kMaxMatches; ++i)
     child_at(i)->SetVisible(false);
 
   // We want the popup to appear to overlay the bottom of the toolbar. So we
   // shift the popup to completely cover the client edge, and then draw an
   // additional semitransparent shadow above that.
-  int top_edge_overlap = views::NonClientFrameView::kClientEdgeThickness +
-                         g_top_shadow.Get().height();
+  int top_edge_overlap =
+      views::NonClientFrameView::kClientEdgeThickness /*+ g_top_shadow_height*/;
 
   gfx::Point top_left_screen_coord;
   int width;
   location_bar_view_->GetOmniboxPopupPositioningInfo(
       &top_left_screen_coord, &width, &start_margin_,
       &end_margin_, top_edge_overlap);
   gfx::Rect new_target_bounds(top_left_screen_coord,
                               gfx::Size(width, CalculatePopupHeight()));
 
   // If we're animating and our target height changes, reset the animation.
   // NOTE: If we just reset blindly on _every_ update, then when the user types
   // rapidly we could get "stuck" trying repeatedly to animate shrinking by the
   // last few pixels to get to one visible result.
   if (new_target_bounds.height() != target_bounds_.height())
     size_animation_.Reset();
   target_bounds_ = new_target_bounds;
 
   if (!popup_) {
+    // Create a new layer even if one already exists to make sure it's correctly
+    // parented.
+    SetPaintToLayer(false);
+    SetPaintToLayer(true);
+    layer()->SetFillsBoundsOpaquely(false);
+    layer()->Add(shadow_layer_.get());
+
     views::Widget* popup_parent = location_bar_view_->GetWidget();
 
     // If the popup is currently closed, we need to create it.
     popup_ = (new AutocompletePopupWidget(popup_parent))->AsWeakPtr();
 
     views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
 #if defined(OS_WIN)
     // On Windows use the software compositor to ensure that we don't block
     // the UI thread blocking issue during command buffer creation. We can
     // revert this change once http://crbug.com/125248 is fixed.
@@ skipping 91 matching lines @@
   // We need to manually schedule a paint here since we are a layered window and
   // won't implicitly require painting until we ask for one.
   SchedulePaint();
 }
 
 views::View* OmniboxPopupContentsView::GetTooltipHandlerForPoint(
     const gfx::Point& point) {
   return nullptr;
 }
 
+void OmniboxPopupContentsView::OnBoundsChanged(
+    const gfx::Rect& previous_bounds) {
+  gfx::Rect shadow_bounds = GetLocalBounds();
+  shadow_layer_->UpdateNinePatchOcclusion(shadow_bounds);
+  shadow_bounds.Inset(
+      gfx::Insets(-g_top_shadow_height, 0, -g_bottom_shadow_height, 0));
+  shadow_layer_->SetBounds(shadow_bounds);
+}
+
 bool OmniboxPopupContentsView::OnMousePressed(
     const ui::MouseEvent& event) {
   ignore_mouse_drag_ = false;  // See comment on |ignore_mouse_drag_| in header.
   if (event.IsLeftMouseButton() || event.IsMiddleMouseButton())
     UpdateLineEvent(event, event.IsLeftMouseButton());
   return true;
 }
 
 bool OmniboxPopupContentsView::OnMouseDragged(
     const ui::MouseEvent& event) {
@@ skipping 57 matching lines @@
 
 int OmniboxPopupContentsView::CalculatePopupHeight() {
   DCHECK_GE(static_cast<size_t>(child_count()), model_->result().size());
   int popup_height = 0;
   for (size_t i = 0; i < model_->result().size(); ++i)
     popup_height += child_at(i)->GetPreferredSize().height();
 
   // Add enough space on the top and bottom so it looks like there is the same
   // amount of space between the text and the popup border as there is in the
   // interior between each row of text.
-  return popup_height + kPopupVerticalPadding * 2 +
-         g_top_shadow.Get().height() + g_bottom_shadow.Get().height();
+  return popup_height + kPopupVerticalPadding * 2;
 }
 
 OmniboxResultView* OmniboxPopupContentsView::CreateResultView(
     int model_index,
     const gfx::FontList& font_list) {
   return new OmniboxResultView(this, model_index, font_list);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OmniboxPopupContentsView, views::View overrides, private:
 
 const char* OmniboxPopupContentsView::GetClassName() const {
   return "OmniboxPopupContentsView";
 }
 
-void OmniboxPopupContentsView::OnPaint(gfx::Canvas* canvas) {
-  canvas->TileImageInt(g_top_shadow.Get(), 0, 0, width(),
-                       g_top_shadow.Get().height());
-  canvas->TileImageInt(g_bottom_shadow.Get(), 0,
-                       height() - g_bottom_shadow.Get().height(), width(),
-                       g_bottom_shadow.Get().height());
-}
-
 void OmniboxPopupContentsView::PaintChildren(const ui::PaintContext& context) {
   gfx::Rect contents_bounds = GetContentsBounds();
-  contents_bounds.Inset(0, g_top_shadow.Get().height(), 0,
-                        g_bottom_shadow.Get().height());
 
   ui::ClipRecorder clip_recorder(context);
   clip_recorder.ClipRect(contents_bounds);
   {
     ui::PaintRecorder recorder(context, size());
     SkColor background_color = result_view_at(0)->GetColor(
         OmniboxResultView::NORMAL, OmniboxResultView::BACKGROUND);
     recorder.canvas()->DrawColor(background_color);
   }
   View::PaintChildren(context);
@@ skipping 49 matching lines @@
   size_t index = GetIndexForPoint(event.location());
   if (!HasMatchAt(index))
     return;
   omnibox_view_->OpenMatch(model_->result().match_at(index), disposition,
                            GURL(), base::string16(), index);
 }
 
 OmniboxResultView* OmniboxPopupContentsView::result_view_at(size_t i) {
   return static_cast<OmniboxResultView*>(child_at(static_cast<int>(i)));
 }