Allow moving cursors between connected displays.

ash/display/display_util.cc

 // Copyright 2014 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/display/display_util.h"
 
 #include <algorithm>
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
@@ skipping 204 matching lines @@
     return false;
   return display_manager->SetDisplayMode(id, mode);
 }
 
 bool HasDisplayModeForUIScale(const DisplayInfo& info, float ui_scale) {
   ScaleComparator comparator(ui_scale);
   const std::vector<DisplayMode>& modes = info.display_modes();
   return std::find_if(modes.begin(), modes.end(), comparator) != modes.end();
 }
 
-void ComputeBoundary(const gfx::Display& a_display,
+bool ComputeBoundary(const gfx::Display& a_display,
                      const gfx::Display& b_display,
                      gfx::Rect* a_edge_in_screen,
                      gfx::Rect* b_edge_in_screen) {
   const gfx::Rect& a_bounds = a_display.bounds();
   const gfx::Rect& b_bounds = b_display.bounds();
 
   // Find touching side.
   int rx = std::max(a_bounds.x(), b_bounds.x());
   int ry = std::max(a_bounds.y(), b_bounds.y());
   int rr = std::min(a_bounds.right(), b_bounds.right());
   int rb = std::min(a_bounds.bottom(), b_bounds.bottom());
 
   DisplayPlacement::Position position;
   if ((rb - ry) == 0) {
     // top bottom
     if (a_bounds.bottom() == b_bounds.y()) {
       position = DisplayPlacement::BOTTOM;
+    } else if (a_bounds.y() == b_bounds.bottom()) {
+      position = DisplayPlacement::TOP;
     } else {
-      DCHECK_EQ(a_bounds.y(), b_bounds.bottom());
-      position = DisplayPlacement::TOP;
+      return false;
     }
   } else {
-    DCHECK((rr - rx) == 0);
     // left right
     if (a_bounds.right() == b_bounds.x()) {
       position = DisplayPlacement::RIGHT;
+    } else if (a_bounds.x() == b_bounds.right()) {
+      position = DisplayPlacement::LEFT;
     } else {
-      DCHECK_EQ(a_bounds.x(), b_bounds.right());
-      position = DisplayPlacement::LEFT;
+      DCHECK_NE(rr, rx);
+      return false;
     }
   }
 
   switch (position) {
     case DisplayPlacement::TOP:
     case DisplayPlacement::BOTTOM: {
       int left = std::max(a_bounds.x(), b_bounds.x());
       int right = std::min(a_bounds.right(), b_bounds.right());
       if (position == DisplayPlacement::TOP) {
         a_edge_in_screen->SetRect(left, a_bounds.y(), right - left, 1);
         b_edge_in_screen->SetRect(left, b_bounds.bottom() - 1, right - left, 1);
       } else {
         a_edge_in_screen->SetRect(left, a_bounds.bottom() - 1, right - left, 1);
         b_edge_in_screen->SetRect(left, b_bounds.y(), right - left, 1);
       }
       break;
     }
     case DisplayPlacement::LEFT:
     case DisplayPlacement::RIGHT: {
       int top = std::max(a_bounds.y(), b_bounds.y());
       int bottom = std::min(a_bounds.bottom(), b_bounds.bottom());
       if (position == DisplayPlacement::LEFT) {
         a_edge_in_screen->SetRect(a_bounds.x(), top, 1, bottom - top);
         b_edge_in_screen->SetRect(b_bounds.right() - 1, top, 1, bottom - top);
       } else {
         a_edge_in_screen->SetRect(a_bounds.right() - 1, top, 1, bottom - top);
-        b_edge_in_screen->SetRect(b_bounds.y(), top, 1, bottom - top);
+        b_edge_in_screen->SetRect(b_bounds.x(), top, 1, bottom - top);
       }
       break;
     }
   }
+  return true;
 }
 
 gfx::Rect GetNativeEdgeBounds(AshWindowTreeHost* ash_host,
                               const gfx::Rect& bounds_in_screen) {
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
   gfx::Rect native_bounds = host->GetBounds();
   native_bounds.Inset(ash_host->GetHostInsets());
   gfx::Point start_in_native = bounds_in_screen.origin();
   gfx::Point end_in_native = bounds_in_screen.bottom_right();
 
@@ skipping 80 matching lines @@
       list.begin(), list.end(),
       [](const gfx::Display& display) { return display.id(); });
 }
 
 void SortDisplayIdList(DisplayIdList* ids) {
   std::sort(ids->begin(), ids->end(),
             [](int64_t a, int64_t b) { return CompareDisplayIds(a, b); });
 }
 
 std::string DisplayIdListToString(const ash::DisplayIdList& list) {
-  return base::Int64ToString(list[0]) + "," + base::Int64ToString(list[1]);
+  std::stringstream s;
+  const char* sep = "";
+  for (int64_t id : list) {
+    s << sep << id;
+    sep = ",";
+  }
+  return s.str();
 }
 
 bool CompareDisplayIds(int64_t id1, int64_t id2) {
   DCHECK_NE(id1, id2);
   // Output index is stored in the first 8 bits. See GetDisplayIdFromEDID
   // in edid_parser.cc.
   int index_1 = id1 & 0xFF;
   int index_2 = id2 & 0xFF;
   DCHECK_NE(index_1, index_2) << id1 << " and " << id2;
   return gfx::Display::IsInternalDisplayId(id1) ||
          (index_1 < index_2 && !gfx::Display::IsInternalDisplayId(id2));
 }
 
 }  // namespace ash