[win] Ensure the app launcher always comes up on screen.

chrome/browser/ui/views/app_list/app_list_controller_win.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 <sstream>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 527 matching lines @@
 
   *rect = gfx::Rect(win_rect);
   return true;
 }
 
 // Used to position the view relative to a point, which requires |anchor| to be
 // in the center of the desired view location. This helper function updates
 // |anchor| thus, using the location of the point in |point|, the distance
 // to move the view from |point| in |offset|, and the direction to move
 // represented in |direction|.
+// The function will also ensure the view is within |offset| of the screen
+// edges.
 // To position relative to a screen corner, the absolute values of |direction|.x
 // and |direction.y| should both be 1. To position relative to some point on the
 // taskbar, one of the absolute values of |direction.x| and |direction.y| should
 // be 1 and the other 0.
 void FloatFromPoint(const gfx::Point& point,
                     const gfx::Size& offset,
                     const gfx::Point& direction,
+                    const gfx::Rect& screen_rect,

[tapted, 2013/02/27 08:41:59]

bounds_rect, Then,

                     gfx::Point* anchor) {
   anchor->set_x(point.x() + direction.x() * offset.width());
   anchor->set_y(point.y() + direction.y() * offset.height());
+
+  if (anchor->x() - offset.width() < screen_rect.x())

[tapted, 2013/02/27 08:41:59]

I think these 11 lines can be just

anchor.ClampToMin(bounds_rect.bottom_left());
anchor.ClampToMax(bounds_rect.top_right());

+    anchor->set_x(screen_rect.x() + offset.width());
+
+  if (anchor->x() + offset.width() > screen_rect.right())
+    anchor->set_x(screen_rect.right() - offset.width());
+
+  if (anchor->y() - offset.height() < screen_rect.y())
+    anchor->set_y(screen_rect.y() + offset.height());
+
+  if (anchor->y() + offset.height() > screen_rect.bottom())
+    anchor->set_y(screen_rect.bottom() - offset.height());
 }
 
 void AppListController::SnapArrowLocationToTaskbarEdge(
     const gfx::Display& display,
     gfx::Point* anchor) {
   const int kSnapDistance = 50;
   const int kSnapOffset = 5;
 
   gfx::Rect taskbar_rect;
   gfx::Size float_offset = current_view_->GetPreferredSize();
   float_offset.set_width(float_offset.width() / 2);
   float_offset.set_height(float_offset.height() / 2);
   float_offset.Enlarge(kSnapOffset, kSnapOffset);

[tapted, 2013/02/27 08:42:30]

[ I think with this Enlarge, it also gets a margin around the edge of the
screen. i.e., it won't be flush against the edge of screen. Intentional? (if no,
this could be moved below the "Inset" in the next comment..) ]

 
+  const gfx::Rect& screen_rect = display.bounds();

[tapted, 2013/02/27 08:41:59]

With

gfx::Rect& bounds_rect = display.bounds();
bounds_rect.Inset(float_offset.width(), float_offset.height());

[tapted, 2013/02/27 08:41:59]

Does it need to take into account the taskbar, to ensure there is no overlap?
(My brain can't really come up with a scenario where that wouldn't be taken care
of by other the things below).

+
   // If we can't find the taskbar, snap to the bottom left.
   // If the display size is the same as the work area, and does not contain the
   // taskbar, either the taskbar is hidden or on another monitor, so just snap
   // to the bottom left.
   if (!GetTaskbarRect(&taskbar_rect) ||
       (display.work_area() == display.bounds() &&
           !display.work_area().Contains(taskbar_rect))) {
     FloatFromPoint(display.work_area().bottom_left(),
                    float_offset,
                    gfx::Point(1, -1),
+                   screen_rect,
                    anchor);
     return;
   }
 
-  const gfx::Rect& screen_rect = display.bounds();
-
   // Snap to the taskbar edge. If the cursor is greater than kSnapDistance away,
   // also move to the left (for horizontal taskbars) or top (for vertical).
 
   // First handle taskbar on bottom.
   if (taskbar_rect.width() == screen_rect.width()) {
     if (taskbar_rect.bottom() == screen_rect.bottom()) {
       if (taskbar_rect.y() - anchor->y() > kSnapDistance) {
         FloatFromPoint(gfx::Point(screen_rect.x(), taskbar_rect.y()),
                        float_offset,
                        gfx::Point(1, -1),
+                       screen_rect,
                        anchor);
         return;
       }
 
       FloatFromPoint(gfx::Point(anchor->x(), taskbar_rect.y()),
                      float_offset,
                      gfx::Point(0, -1),
+                     screen_rect,
                      anchor);
       return;
     }
 
     // Now try on the top.
     if (anchor->y() - taskbar_rect.bottom() > kSnapDistance) {
       FloatFromPoint(gfx::Point(screen_rect.x(), taskbar_rect.bottom()),
                      float_offset,
                      gfx::Point(1, 1),
+                     screen_rect,
                      anchor);
       return;
     }
 
     FloatFromPoint(gfx::Point(anchor->x(), taskbar_rect.bottom()),
                    float_offset,
                    gfx::Point(0, 1),
+                   screen_rect,
                    anchor);
     return;
   }
 
   // Now try the left.
   if (taskbar_rect.x() == screen_rect.x()) {
     if (anchor->x() - taskbar_rect.right() > kSnapDistance) {
       FloatFromPoint(gfx::Point(taskbar_rect.right(), screen_rect.y()),
                      float_offset,
                      gfx::Point(1, 1),
+                     screen_rect,
                      anchor);
       return;
     }
 
     FloatFromPoint(gfx::Point(taskbar_rect.right(), anchor->y()),
                    float_offset,
                    gfx::Point(1, 0),
+                   screen_rect,
                    anchor);
     return;
   }
 
   // Finally, try the right.
   if (taskbar_rect.x() - anchor->x() > kSnapDistance) {
     FloatFromPoint(gfx::Point(taskbar_rect.x(), screen_rect.y()),
                    float_offset,
                    gfx::Point(-1, 1),
+                   screen_rect,
                    anchor);
     return;
   }
 
   FloatFromPoint(gfx::Point(taskbar_rect.x(), anchor->y()),
                  float_offset,
                  gfx::Point(-1, 0),
+                 screen_rect,
                  anchor);
 }
 
 void AppListController::UpdateArrowPositionAndAnchorPoint(
     const gfx::Point& cursor) {
   gfx::Point anchor(cursor);
   gfx::Screen* screen =
       gfx::Screen::GetScreenFor(current_view_->GetWidget()->GetNativeView());
   gfx::Display display = screen->GetDisplayNearestPoint(anchor);
 
@@ skipping 211 matching lines @@
 
 Profile* GetCurrentAppListProfile() {
   return GetCurrentAppListController()->profile();
 }
 
 bool IsAppListVisible() {
   return GetCurrentAppListController()->IsAppListVisible();
 }
 
 }  // namespace chrome