Remove legacy draggable region code and refactor to share common draggable region code

chrome/browser/ui/views/extensions/shell_window_views.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/extensions/shell_window_views.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
@@ skipping 192 matching lines @@
                                                resize_border,
                                                resize_border,
                                                kResizeAreaCornerSize,
                                                kResizeAreaCornerSize,
                                                can_ever_resize);
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   // Check for possible draggable region in the client area for the frameless
   // window.
-  if (window_->frameless() &&
-      window_->draggable_region() &&
-      window_->draggable_region()->contains(point.x(), point.y()))
+  if (window_->IsInsideDraggableRegions(point.x(), point.y()))
     return HTCAPTION;
 
   int client_component = frame_->client_view()->NonClientHitTest(point);
   if (client_component != HTNOWHERE)
     return client_component;
 
   // Then see if the point is within any of the window controls.
   if (close_button_ && close_button_->visible() &&
       close_button_->GetMirroredBounds().Contains(point))
     return HTCLOSE;
@@ skipping 84 matching lines @@
 
 void ShellWindowFrameView::ButtonPressed(views::Button* sender,
                                          const ui::Event& event) {
   DCHECK(!window_->frameless());
   if (sender == close_button_)
     frame_->Close();
 }
 
 ShellWindowViews::ShellWindowViews(ShellWindow* shell_window,
                                    const ShellWindow::CreateParams& win_params)
-    : shell_window_(shell_window),
+    : NativeShellWindow(win_params),
+      shell_window_(shell_window),
       web_view_(NULL),
-      is_fullscreen_(false),
-      frameless_(win_params.frame == ShellWindow::CreateParams::FRAME_NONE) {
+      is_fullscreen_(false) {
   window_ = new views::Widget;
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.delegate = this;
   params.remove_standard_frame = true;
   params.use_system_default_icon = true;
   minimum_size_ = win_params.minimum_size;
   maximum_size_ = win_params.maximum_size;
   window_->Init(params);
   gfx::Rect window_bounds =
       window_->non_client_view()->GetWindowBoundsForClientBounds(
@@ skipping 26 matching lines @@
   return web_view_;
 }
 
 bool ShellWindowViews::ShouldDescendIntoChildForEventHandling(
     gfx::NativeView child,
     const gfx::Point& location) {
 #if defined(USE_AURA)
   DCHECK_EQ(child, web_view_->web_contents()->GetView()->GetNativeView());
   // Shell window should claim mouse events that fall within the draggable
   // region.
-  return !draggable_region_.get() ||
-         !draggable_region_->contains(location.x(), location.y());
+  return !IsInsideDraggableRegions(location.x(), location.y());
 #else
   return true;
 #endif
 }
 
 void ShellWindowViews::OnFocus() {
   web_view_->RequestFocus();
 }
 
 void ShellWindowViews::ViewHierarchyChanged(
@@ skipping 120 matching lines @@
   return CanResize();
 }
 
 views::View* ShellWindowViews::GetContentsView() {
   return this;
 }
 
 views::NonClientFrameView* ShellWindowViews::CreateNonClientFrameView(
     views::Widget* widget) {
 #if defined(USE_ASH)
-  if (!frameless_) {
+  if (!frameless()) {
     ash::CustomFrameViewAsh* frame = new ash::CustomFrameViewAsh();
     frame->Init(widget);
     return frame;
   }
 #endif
   ShellWindowFrameView* frame_view = new ShellWindowFrameView(this);
   frame_view->Init(window_);
   return frame_view;
 }
 
@@ skipping 17 matching lines @@
   DCHECK(window_);
   DCHECK(web_view_);
   gfx::Size sz = web_view_->size();
   int height = sz.height(), width = sz.width();
   int radius = 1;
   gfx::Path path;
   if (window_->IsMaximized() || window_->IsFullscreen()) {
     // Don't round the corners when the window is maximized or fullscreen.
     path.addRect(0, 0, width, height);
   } else {
-    if (frameless_) {
+    if (frameless()) {
       path.moveTo(0, radius);
       path.lineTo(radius, 0);
       path.lineTo(width - radius, 0);
       path.lineTo(width, radius);
     } else {
       // Don't round the top corners in chrome-style frame mode.
       path.moveTo(0, 0);
       path.lineTo(width, 0);
     }
     path.lineTo(width, height - radius - 1);
     path.lineTo(width - radius - 1, height);
     path.lineTo(radius + 1, height);
     path.lineTo(0, height - radius - 1);
     path.close();
   }
   SetWindowRgn(web_contents()->GetNativeView(), path.CreateNativeRegion(), 1);
 
   SkRegion* rgn = new SkRegion;
   if (!window_->IsFullscreen()) {
-    if (draggable_region())
-      rgn->op(*draggable_region(), SkRegion::kUnion_Op);
+    if (draggable_regions())
+      rgn->op(*draggable_regions(), SkRegion::kUnion_Op);
     if (!window_->IsMaximized()) {
-      if (frameless_)
+      if (frameless())
         rgn->op(0, 0, width, kResizeInsideBoundsSize, SkRegion::kUnion_Op);
       rgn->op(0, 0, kResizeInsideBoundsSize, height, SkRegion::kUnion_Op);
       rgn->op(width - kResizeInsideBoundsSize, 0, width, height,
           SkRegion::kUnion_Op);
       rgn->op(0, height - kResizeInsideBoundsSize, width, height,
           SkRegion::kUnion_Op);
     }
   }
   if (web_contents()->GetRenderViewHost()->GetView())
     web_contents()->GetRenderViewHost()->GetView()->SetClickthroughRegion(rgn);
@@ skipping 34 matching lines @@
   window_->UpdateWindowIcon();
 }
 
 void ShellWindowViews::UpdateWindowTitle() {
   window_->UpdateWindowTitle();
 }
 
 void ShellWindowViews::UpdateDraggableRegions(
     const std::vector<extensions::DraggableRegion>& regions) {
   // Draggable region is not supported for non-frameless window.
-  if (!frameless_)
+  if (!frameless())
     return;
 
-  SkRegion* draggable_region = new SkRegion;
-
-  // By default, the whole window is non-draggable. We need to explicitly
-  // include those draggable regions.
-  for (std::vector<extensions::DraggableRegion>::const_iterator iter =
-           regions.begin();
-       iter != regions.end(); ++iter) {
-    const extensions::DraggableRegion& region = *iter;
-    draggable_region->op(
-        region.bounds.x(),
-        region.bounds.y(),
-        region.bounds.right(),
-        region.bounds.bottom(),
-        region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
-  }
-
-  draggable_region_.reset(draggable_region);
+  NativeShellWindow::UpdateDraggableRegions(regions);
   OnViewWasResized();
 }
 
-void ShellWindowViews::UpdateLegacyDraggableRegions(
-    const std::vector<extensions::DraggableRegion>& regions) {
-  // Draggable region is not supported for non-frameless window.
-  if (!frameless_)
-    return;
-
-  SkRegion* draggable_region = new SkRegion;
-
-  // By default, the whole window is draggable.
-  gfx::Rect bounds = GetBounds();
-  draggable_region->op(0, 0, bounds.right(), bounds.bottom(),
-                       SkRegion::kUnion_Op);
-
-  // Exclude those desinated as non-draggable.
-  for (std::vector<extensions::DraggableRegion>::const_iterator iter =
-           regions.begin();
-       iter != regions.end(); ++iter) {
-    const extensions::DraggableRegion& region = *iter;
-    draggable_region->op(region.bounds.x(),
-                         region.bounds.y(),
-                         region.bounds.right(),
-                         region.bounds.bottom(),
-                         SkRegion::kDifference_Op);
-  }
-
-  draggable_region_.reset(draggable_region);
-  OnViewWasResized();
-}
-
 void ShellWindowViews::HandleKeyboardEvent(
     const content::NativeWebKeyboardEvent& event) {
   unhandled_keyboard_event_handler_.HandleKeyboardEvent(event,
                                                         GetFocusManager());
 }
 
 void ShellWindowViews::SaveWindowPlacement(const gfx::Rect& bounds,
                                            ui::WindowShowState show_state) {
   views::WidgetDelegate::SaveWindowPlacement(bounds, show_state);
   shell_window_->SaveWindowPosition();
 }
 
 // static
 NativeShellWindow* NativeShellWindow::Create(
     ShellWindow* shell_window, const ShellWindow::CreateParams& params) {
   return new ShellWindowViews(shell_window, params);
 }