Moves windowsresizers to ash/wm/common

ash/wm/common/workspace/magnetism_matcher.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/workspace/magnetism_matcher.h"
+#include "ash/wm/common/workspace/magnetism_matcher.h"
 
 #include <algorithm>
 #include <cmath>
 
 namespace ash {
 namespace {
 
 // Returns true if |a| is close enough to |b| that the two edges snap.
 bool IsCloseEnough(int a, int b) {
   return abs(a - b) <= MagnetismMatcher::kMagneticDistance;
@@ skipping 29 matching lines @@
   }
   return (edges & secondary_as_magnetism_edge) != 0;
 }
 
 }  // namespace
 
 // MagnetismEdgeMatcher --------------------------------------------------------
 
 MagnetismEdgeMatcher::MagnetismEdgeMatcher(const gfx::Rect& bounds,
                                            MagnetismEdge edge)
-    : bounds_(bounds),
-      edge_(edge) {
+    : bounds_(bounds), edge_(edge) {
   ranges_.push_back(GetSecondaryRange(bounds_));
 }
 
-MagnetismEdgeMatcher::~MagnetismEdgeMatcher() {
-}
+MagnetismEdgeMatcher::~MagnetismEdgeMatcher() {}
 
 bool MagnetismEdgeMatcher::ShouldAttach(const gfx::Rect& bounds) {
   if (is_edge_obscured())
     return false;
 
   if (IsCloseEnough(GetPrimaryCoordinate(bounds_, edge_),
                     GetPrimaryCoordinate(bounds, FlipEdge(edge_)))) {
     const Range range(GetSecondaryRange(bounds));
     Ranges::const_iterator i =
         std::lower_bound(ranges_.begin(), ranges_.end(), range);
@@ skipping 15 matching lines @@
 
 void MagnetismEdgeMatcher::UpdateRanges(const Range& range) {
   Ranges::const_iterator it =
       std::lower_bound(ranges_.begin(), ranges_.end(), range);
   if (it != ranges_.begin() && RangesIntersect(*(it - 1), range))
     --it;
   if (it == ranges_.end())
     return;
 
   for (size_t i = it - ranges_.begin();
-       i < ranges_.size() && RangesIntersect(ranges_[i], range); ) {
-    if (range.first <= ranges_[i].first &&
-        range.second >= ranges_[i].second) {
+       i < ranges_.size() && RangesIntersect(ranges_[i], range);) {
+    if (range.first <= ranges_[i].first && range.second >= ranges_[i].second) {
       ranges_.erase(ranges_.begin() + i);
     } else if (range.first < ranges_[i].first) {
       DCHECK_GT(range.second, ranges_[i].first);
       ranges_[i] = Range(range.second, ranges_[i].second);
       ++i;
     } else {
       Range existing(ranges_[i]);
       ranges_[i].second = range.first;
       ++i;
       if (existing.second > range.second) {
@@ skipping 10 matching lines @@
 // static
 const int MagnetismMatcher::kMagneticDistance = 8;
 
 MagnetismMatcher::MagnetismMatcher(const gfx::Rect& bounds, uint32_t edges)
     : edges_(edges) {
   if (edges & MAGNETISM_EDGE_TOP)
     matchers_.push_back(new MagnetismEdgeMatcher(bounds, MAGNETISM_EDGE_TOP));
   if (edges & MAGNETISM_EDGE_LEFT)
     matchers_.push_back(new MagnetismEdgeMatcher(bounds, MAGNETISM_EDGE_LEFT));
   if (edges & MAGNETISM_EDGE_BOTTOM) {
-    matchers_.push_back(new MagnetismEdgeMatcher(bounds,
-                                                 MAGNETISM_EDGE_BOTTOM));
+    matchers_.push_back(
+        new MagnetismEdgeMatcher(bounds, MAGNETISM_EDGE_BOTTOM));
   }
   if (edges & MAGNETISM_EDGE_RIGHT)
     matchers_.push_back(new MagnetismEdgeMatcher(bounds, MAGNETISM_EDGE_RIGHT));
 }
 
-MagnetismMatcher::~MagnetismMatcher() {
-}
+MagnetismMatcher::~MagnetismMatcher() {}
 
 bool MagnetismMatcher::ShouldAttach(const gfx::Rect& bounds,
                                     MatchedEdge* edge) {
   for (size_t i = 0; i < matchers_.size(); ++i) {
     if (matchers_[i]->ShouldAttach(bounds)) {
       edge->primary_edge = matchers_[i]->edge();
       AttachToSecondaryEdge(bounds, edge->primary_edge,
                             &(edge->secondary_edge));
       return true;
     }
@@ skipping 33 matching lines @@
                                      edges_) &&
                IsCloseEnough(bounds.right(), src_bounds.right())) {
       *secondary_edge = SECONDARY_MAGNETISM_EDGE_TRAILING;
     } else {
       *secondary_edge = SECONDARY_MAGNETISM_EDGE_NONE;
     }
   }
 }
 
 }  // namespace ash