Adding proper dragging behavior for L/R maximized windows.

ash/wm/frame_painter.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 "ash/wm/frame_painter.h"
 
 #include "ash/ash_constants.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
+#include "ash/wm/property_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/logging.h"  // DCHECK
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/screen.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace {
 // TODO(jamescook): Border is specified to be a single pixel overlapping
 // the web content and may need to be built into the shadow layers instead.
 const int kBorderThickness = 0;
 // Space between left edge of window and popup window icon.
 const int kIconOffsetX = 4;
@@ skipping 200 matching lines @@
   // fullscreen, as it can't be resized in those states.
   int resize_border =
       frame_->IsMaximized() || frame_->IsFullscreen() ? 0 :
       kResizeInsideBoundsSize;
   int frame_component = view->GetHTComponentForFrame(point,
                                                      resize_border,
                                                      resize_border,
                                                      kResizeAreaCornerSize,
                                                      kResizeAreaCornerSize,
                                                      can_ever_resize);
+  frame_component = AdjustFrameHitCodeForMaximizedModes(frame_component);
   if (frame_component != HTNOWHERE)
     return frame_component;
 
   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_->visible() &&
       close_button_->GetMirroredBounds().Contains(point))
@@ skipping 328 matching lines @@
   // Single browser window is very transparent.
   if (UseSoloWindowHeader())
     return kSoloWindowOpacity;
 
   // Otherwise, change transparency based on window activation status.
   if (header_mode == ACTIVE)
     return kActiveWindowOpacity;
   return kInactiveWindowOpacity;
 }
 
+int FramePainter::AdjustFrameHitCodeForMaximizedModes(int hit_code) {
+  if (hit_code != HTNOWHERE) {

[sky, 2012/09/05 17:03:24]

Why does this logic depend upon having restore bounds? Isn't the important thing
that the window fills the width or height and is normal? Also, shouldn't this do
the same thing if the window fills the horizontal space? You can get in the
later state if you double click the left/right edge.

[Mr4D (OOO till 08-26), 2012/09/06 16:06:54]

Due to our snapping: I don't think so. You can get very easy into a state where
the window is placed to trigger this behavior in an incorrect situation.
Checking for the restore bounds avoids this problem (and is secure & correct).

Filling horizontal space: A. another "undiscoverable" feature... (thanks for
pointing that out!). B. Was not requested, but makes sense. Done.

+    // When there is a restore rectangle, a left/right maximized window might
+    // be active.
+    if (wm::IsWindowNormal(window_) && GetRestoreBoundsInScreen(window_)) {
+      gfx::Rect bounds = window_->bounds();
+      gfx::Rect screen = gfx::Screen::GetDisplayMatching(bounds).work_area();
+      if (bounds.y() == screen.y() && bounds.bottom() == screen.bottom()) {
+        // The window is probably either left or right maximized.
+        if (bounds.x() == screen.x()) {
+          // It is left maximized and we can only allow a right resize.
+          return (hit_code == HTBOTTOMRIGHT ||
+                  hit_code == HTTOPRIGHT ||
+                  hit_code == HTRIGHT) ? HTRIGHT : HTNOWHERE;
+        } else if (bounds.right() == screen.right()) {
+          // It is right maximized and we can only allow a left resize.
+          return (hit_code == HTBOTTOMLEFT ||
+                  hit_code == HTTOPLEFT ||
+                  hit_code == HTLEFT) ? HTLEFT : HTNOWHERE;
+        }
+      }
+    }
+  }
+  return hit_code;
+}
+
 // static
 bool FramePainter::UseSoloWindowHeader() {
   if (!instances_)
     return false;  // Return value shouldn't matter.
 
   aura::Window* window = NULL;
   for (std::set<FramePainter*>::const_iterator it = instances_->begin();
        it != instances_->end();
        ++it) {
     // The window needs to be a 'normal window'. To exclude constrained windows
@@ skipping 19 matching lines @@
   for (std::set<FramePainter*>::const_iterator it = instances_->begin();
        it != instances_->end();
        ++it) {
     FramePainter* painter = *it;
     if (IsVisibleNormalWindow(painter->window_))
       painter->frame_->non_client_view()->SchedulePaint();
   }
 }
 
 }  // namespace ash