Added Layer based clipping to MenuScrollViewContainer::MenuScrollView

ui/views/controls/menu/menu_scroll_view_container.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/menu/menu_scroll_view_container.h"
 
 #include "base/macros.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/accessibility/ax_view_state.h"
+#include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/views/border.h"
 #include "ui/views/bubble/bubble_border.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/round_rect_painter.h"
 
 using ui::NativeTheme;
 
 namespace views {
 
 namespace {
 
 static const int kBorderPaddingDueToRoundedCorners = 1;
 
 // MenuScrollButton ------------------------------------------------------------
 
 // MenuScrollButton is used for the scroll buttons when not all menu items fit
 // on screen. MenuScrollButton forwards appropriate events to the
 // MenuController.
 
 class MenuScrollButton : public View {
  public:
+  static const char kViewClassName[];
+
   MenuScrollButton(SubmenuView* host, bool is_up)
       : host_(host),
         is_up_(is_up),
         // Make our height the same as that of other MenuItemViews.
         pref_height_(MenuItemView::pref_menu_height()) {
   }
 
+  const char* GetClassName() const override { return kViewClassName; }
+
   gfx::Size GetPreferredSize() const override {
     return gfx::Size(MenuConfig::instance().scroll_arrow_height * 2 - 1,
                      pref_height_);
   }
 
   bool CanDrop(const OSExchangeData& data) override {
     DCHECK(host_->GetMenuItem()->GetMenuController());
     return true;  // Always return true so that drop events are targeted to us.
   }
 
@@ skipping 59 matching lines @@
 
   // Direction of the button.
   bool is_up_;
 
   // Preferred height.
   int pref_height_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuScrollButton);
 };
 
+// static
+const char MenuScrollButton::kViewClassName[] = "MenuScrollButton";
+
 }  // namespace
 
 // MenuScrollView --------------------------------------------------------------
 
 // MenuScrollView is a viewport for the SubmenuView. It's reason to exist is so
 // that ScrollRectToVisible works.
 //
 // NOTE: It is possible to use ScrollView directly (after making it deal with
 // null scrollbars), but clicking on a child of ScrollView forces the window to
 // become active, which we don't want. As we really only need a fraction of
 // what ScrollView does, so we use a one off variant.
 
 class MenuScrollViewContainer::MenuScrollView : public View {
  public:
+  static const char kViewClassName[];
+
   explicit MenuScrollView(View* child) {
+    SetPaintToLayer(true);
+    layer()->SetMasksToBounds(true);
+    // TODO(bruthig): Paint bounds opaquely.  See http://crbug.com/601135.
+    layer()->SetFillsBoundsOpaquely(false);
     AddChildView(child);
   }
 
+  const char* GetClassName() const override { return kViewClassName; }
+
   void ScrollRectToVisible(const gfx::Rect& rect) override {
     // NOTE: this assumes we only want to scroll in the y direction.
 
     // If the rect is already visible, do not scroll.
     if (GetLocalBounds().Contains(rect))
       return;
 
     // Scroll just enough so that the rect is visible.
     int dy = 0;
     if (rect.bottom() > GetLocalBounds().bottom())
@@ skipping 11 matching lines @@
 
   // Returns the contents, which is the SubmenuView.
   View* GetContents() {
     return child_at(0);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MenuScrollView);
 };
 
+// static
+const char MenuScrollViewContainer::MenuScrollView::kViewClassName[] =
+    "MenuScrollViewContainer::MenuScrollView";
+
 // MenuScrollViewContainer ----------------------------------------------------
 
+// static
+const char MenuScrollViewContainer::kViewClassName[] =
+    "MenuScrollViewContainer";
+
 MenuScrollViewContainer::MenuScrollViewContainer(SubmenuView* content_view)
     : content_view_(content_view),
       arrow_(BubbleBorder::NONE),
       bubble_border_(NULL) {
   scroll_up_button_ = new MenuScrollButton(content_view, true);
   scroll_down_button_ = new MenuScrollButton(content_view, false);
   AddChildView(scroll_up_button_);
   AddChildView(scroll_down_button_);
 
   scroll_view_ = new MenuScrollView(content_view);
@@ skipping 10 matching lines @@
 
 bool MenuScrollViewContainer::HasBubbleBorder() {
   return arrow_ != BubbleBorder::NONE;
 }
 
 void MenuScrollViewContainer::SetBubbleArrowOffset(int offset) {
   DCHECK(HasBubbleBorder());
   bubble_border_->set_arrow_offset(offset);
 }
 
+const char* MenuScrollViewContainer::GetClassName() const {
+  return kViewClassName;
+}
+
 gfx::Size MenuScrollViewContainer::GetPreferredSize() const {
   gfx::Size prefsize = scroll_view_->GetContents()->GetPreferredSize();
   gfx::Insets insets = GetInsets();
   prefsize.Enlarge(insets.width(), insets.height());
   return prefsize;
 }
 
 void MenuScrollViewContainer::Layout() {
   gfx::Insets insets = GetInsets();
   int x = insets.left();
@@ skipping 104 matching lines @@
     case MENU_ANCHOR_BUBBLE_ABOVE:
       return BubbleBorder::BOTTOM_CENTER;
     case MENU_ANCHOR_BUBBLE_BELOW:
       return BubbleBorder::TOP_CENTER;
     default:
       return BubbleBorder::NONE;
   }
 }
 
 }  // namespace views