Mandoline: Rename components/view_manager to components/mus

components/mus/gesture_manager.cc

 // Copyright 2015 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 "components/view_manager/gesture_manager.h"
+#include "components/mus/gesture_manager.h"
 
 #include <algorithm>
 
-#include "components/view_manager/gesture_manager_delegate.h"
-#include "components/view_manager/public/cpp/keys.h"
-#include "components/view_manager/server_view.h"
-#include "components/view_manager/view_coordinate_conversions.h"
-#include "components/view_manager/view_locator.h"
+#include "components/mus/gesture_manager_delegate.h"
+#include "components/mus/public/cpp/keys.h"
+#include "components/mus/server_view.h"
+#include "components/mus/view_coordinate_conversions.h"
+#include "components/mus/view_locator.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/mojo/events/input_events.mojom.h"
 
 namespace view_manager {
 
 using Views = std::vector<const ServerView*>;
 
 namespace {
 
 GestureManager::GestureAndConnectionId MakeGestureAndConnectionId(
@@ skipping 37 matching lines @@
   result->pointer_data->x = target_location.x();
   result->pointer_data->y = target_location.y();
   return result.Pass();
 }
 
 }  // namespace
 
 // GestureStateChange ----------------------------------------------------------
 
 GestureStateChange::GestureStateChange()
-    : chosen_gesture(GestureManager::kInvalidGestureId) {
-}
+    : chosen_gesture(GestureManager::kInvalidGestureId) {}
 
-GestureStateChange::~GestureStateChange() {
-}
+GestureStateChange::~GestureStateChange() {}
 
 // ViewIterator ----------------------------------------------------------------
 
 // Used to iterate over a set of views.
 class ViewIterator {
  public:
   explicit ViewIterator(const Views& views)
       : views_(views), current_(views_.begin()) {}
 
   // Advances to the next view. Returns true if there are no more views (at
@@ skipping 74 matching lines @@
   }
 
  private:
   const uint32_t id_;
   State state_;
   std::set<PointerAndView> pointers_and_views_;
 
   DISALLOW_COPY_AND_ASSIGN(Gesture);
 };
 
-GestureManager::Gesture::Gesture(uint32_t id) : id_(id), state_(STATE_INITIAL) {
-}
+GestureManager::Gesture::Gesture(uint32_t id)
+    : id_(id), state_(STATE_INITIAL) {}
 
-GestureManager::Gesture::~Gesture() {
-}
+GestureManager::Gesture::~Gesture() {}
 
 void GestureManager::Gesture::Attach(Pointer* pointer, const ServerView* view) {
   pointers_and_views_.insert(PointerAndView(pointer, view));
 }
 
 void GestureManager::Gesture::Detach(Pointer* pointer, const ServerView* view) {
   pointers_and_views_.erase(PointerAndView(pointer, view));
 }
 
 // Pointer ---------------------------------------------------------------------
@@ skipping 316 matching lines @@
 
  private:
   GestureManager* manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ScheduledDeleteProcessor);
 };
 
 // PointerAndView --------------------------------------------------------------
 
 GestureManager::PointerAndView::PointerAndView()
-    : pointer(nullptr), view(nullptr) {
-}
+    : pointer(nullptr), view(nullptr) {}
 
 GestureManager::PointerAndView::PointerAndView(Pointer* pointer,
                                                const ServerView* view)
-    : pointer(pointer), view(view) {
-}
+    : pointer(pointer), view(view) {}
 
 bool GestureManager::PointerAndView::operator<(
     const PointerAndView& other) const {
   if (other.pointer->pointer_id() == pointer->pointer_id())
     return view->id().connection_id < other.view->id().connection_id;
   return pointer->pointer_id() < other.pointer->pointer_id();
 }
 
 // GestureManager --------------------------------------------------------------
 
 // static
 const uint32_t GestureManager::kInvalidGestureId = 0u;
 
 GestureManager::GestureManager(GestureManagerDelegate* delegate,
                                const ServerView* root)
-    : delegate_(delegate), root_view_(root) {
-}
+    : delegate_(delegate), root_view_(root) {}
 
 GestureManager::~GestureManager() {
   // Explicitly delete the pointers first as this may result in calling back to
   // us to cleanup and delete gestures.
   active_pointers_.clear();
 }
 
 bool GestureManager::ProcessEvent(const mojo::Event& event) {
   if (!event.pointer_data)
     return false;
@@ skipping 147 matching lines @@
 void GestureManager::ScheduleDelete(Pointer* pointer) {
   auto iter =
       std::find(active_pointers_.begin(), active_pointers_.end(), pointer);
   if (iter != active_pointers_.end()) {
     active_pointers_.weak_erase(iter);
     pointers_to_delete_.push_back(pointer);
   }
 }
 
 }  // namespace view_manager