clang-format all of //ash

ash/drag_drop/drag_drop_controller.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/drag_drop/drag_drop_controller.h"
 
 #include <utility>
 
 #include "ash/drag_drop/drag_drop_tracker.h"
 #include "ash/drag_drop/drag_image_view.h"
@@ skipping 178 matching lines @@
   drag_data_ = &data;
   drag_operation_ = operation;
 
   float drag_image_scale = 1;
   int drag_image_vertical_offset = 0;
   if (source == ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH) {
     drag_image_scale = kTouchDragImageScale;
     drag_image_vertical_offset = kTouchDragImageVerticalOffset;
   }
   gfx::Point start_location = screen_location;
-  drag_image_final_bounds_for_cancel_animation_ = gfx::Rect(
-      start_location - provider->GetDragImageOffset(),
-      provider->GetDragImage().size());
+  drag_image_final_bounds_for_cancel_animation_ =
+      gfx::Rect(start_location - provider->GetDragImageOffset(),
+                provider->GetDragImage().size());
   drag_image_.reset(new DragImageView(source_window->GetRootWindow(), source));
   drag_image_->SetImage(provider->GetDragImage());
   drag_image_offset_ = provider->GetDragImageOffset();
   gfx::Rect drag_image_bounds(start_location, drag_image_->GetPreferredSize());
-  drag_image_bounds = AdjustDragImageBoundsForScaleAndOffset(drag_image_bounds,
-      drag_image_vertical_offset, drag_image_scale, &drag_image_offset_);
+  drag_image_bounds = AdjustDragImageBoundsForScaleAndOffset(
+      drag_image_bounds, drag_image_vertical_offset, drag_image_scale,
+      &drag_image_offset_);
   drag_image_->SetBoundsInScreen(drag_image_bounds);
   drag_image_->SetWidgetVisible(true);
   if (source == ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH) {
-    drag_image_->SetTouchDragOperationHintPosition(gfx::Point(
-        drag_image_offset_.x(),
-        drag_image_offset_.y() + drag_image_vertical_offset));
+    drag_image_->SetTouchDragOperationHintPosition(
+        gfx::Point(drag_image_offset_.x(),
+                   drag_image_offset_.y() + drag_image_vertical_offset));
   }
 
   drag_window_ = NULL;
 
   // Ends cancel animation if it's in progress.
   if (cancel_animation_)
     cancel_animation_->End();
 
   if (should_block_during_drag_drop_) {
     base::RunLoop run_loop;
@@ skipping 68 matching lines @@
         cursor = ui::kCursorGrabbing;
       ash::Shell::GetInstance()->cursor_manager()->SetCursor(cursor);
     }
   }
 
   DCHECK(drag_image_.get());
   if (drag_image_->visible()) {
     gfx::Point root_location_in_screen = event.root_location();
     ::wm::ConvertPointToScreen(target->GetRootWindow(),
                                &root_location_in_screen);
-    drag_image_->SetScreenPosition(
-        root_location_in_screen - drag_image_offset_);
+    drag_image_->SetScreenPosition(root_location_in_screen -
+                                   drag_image_offset_);
     drag_image_->SetTouchDragOperation(op);
   }
 }
 
 void DragDropController::Drop(aura::Window* target,
                               const ui::LocatedEvent& event) {
   ash::Shell::GetInstance()->cursor_manager()->SetCursor(ui::kCursorPointer);
 
   // We must guarantee that a target gets a OnDragEntered before Drop. WebKit
   // depends on not getting a Drop without DragEnter. This behavior is
@@ skipping 101 matching lines @@
   // event will still be dispatched to other handlers and we depend on
   // individual handlers' kindness to not touch events marked ER_HANDLED (not
   // all handlers are so kind and may cause bugs like crbug.com/236493).
   event->StopPropagation();
 
   // If current drag session was not started by touch, dont process this event.
   if (current_drag_event_source_ != ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH)
     return;
 
   // Apply kTouchDragImageVerticalOffset to the location.
-  ui::GestureEvent touch_offset_event(*event,
-                                      static_cast<aura::Window*>(NULL),
+  ui::GestureEvent touch_offset_event(*event, static_cast<aura::Window*>(NULL),
                                       static_cast<aura::Window*>(NULL));
   gfx::PointF touch_offset_location = touch_offset_event.location_f();
   gfx::PointF touch_offset_root_location = touch_offset_event.root_location_f();
   touch_offset_location.Offset(0, kTouchDragImageVerticalOffset);
   touch_offset_root_location.Offset(0, kTouchDragImageVerticalOffset);
   touch_offset_event.set_location_f(touch_offset_location);
   touch_offset_event.set_root_location_f(touch_offset_root_location);
 
   aura::Window* translated_target =
       drag_drop_tracker_->GetTarget(touch_offset_event);
@@ skipping 12 matching lines @@
     case ui::ET_GESTURE_SCROLL_END:
     case ui::ET_SCROLL_FLING_START:
       Drop(translated_target, *translated_event.get());
       break;
     case ui::ET_GESTURE_LONG_TAP:
       // Ideally we would want to just forward this long tap event to the
       // |drag_source_window_|. However, webkit does not accept events while a
       // drag drop is still in progress. The drag drop ends only when the nested
       // message loop ends. Due to this stupidity, we have to defer forwarding
       // the long tap.
-      pending_long_tap_.reset(
-          new ui::GestureEvent(*event,
-              static_cast<aura::Window*>(drag_drop_tracker_->capture_window()),
-              static_cast<aura::Window*>(drag_source_window_)));
+      pending_long_tap_.reset(new ui::GestureEvent(
+          *event,
+          static_cast<aura::Window*>(drag_drop_tracker_->capture_window()),
+          static_cast<aura::Window*>(drag_source_window_)));
       DoDragCancel(kTouchCancelAnimationDuration);
       break;
     default:
       break;
   }
   event->SetHandled();
 }
 
 void DragDropController::OnWindowDestroyed(aura::Window* window) {
   if (drag_window_ == window)
@@ skipping 34 matching lines @@
     }
   }
 }
 
 void DragDropController::DoDragCancel(int drag_cancel_animation_duration_ms) {
   ash::Shell::GetInstance()->cursor_manager()->SetCursor(ui::kCursorPointer);
 
   // |drag_window_| can be NULL if we have just started the drag and have not
   // received any DragUpdates, or, if the |drag_window_| gets destroyed during
   // a drag/drop.
-  aura::client::DragDropDelegate* delegate = drag_window_?
-      aura::client::GetDragDropDelegate(drag_window_) : NULL;
+  aura::client::DragDropDelegate* delegate =
+      drag_window_ ? aura::client::GetDragDropDelegate(drag_window_) : NULL;
   if (delegate)
     delegate->OnDragExited();
 
   Cleanup();
   drag_operation_ = 0;
   StartCanceledAnimation(drag_cancel_animation_duration_ms);
   if (should_block_during_drag_drop_)
     quit_closure_.Run();
 }
 
 void DragDropController::AnimationProgressed(const gfx::Animation* animation) {
   gfx::Rect current_bounds = animation->CurrentValueBetween(
       drag_image_initial_bounds_for_cancel_animation_,
       drag_image_final_bounds_for_cancel_animation_);
   drag_image_->SetBoundsInScreen(current_bounds);
 }
 
 void DragDropController::AnimationCanceled(const gfx::Animation* animation) {
   AnimationEnded(animation);
 }
 
 void DragDropController::StartCanceledAnimation(int animation_duration_ms) {
   DCHECK(drag_image_.get());
   drag_image_->SetTouchDragOperationHintOff();
   drag_image_initial_bounds_for_cancel_animation_ =
       drag_image_->GetBoundsInScreen();
-  cancel_animation_.reset(CreateCancelAnimation(animation_duration_ms,
-                                                kCancelAnimationFrameRate,
-                                                this));
+  cancel_animation_.reset(CreateCancelAnimation(
+      animation_duration_ms, kCancelAnimationFrameRate, this));
   cancel_animation_->Start();
 }
 
 void DragDropController::ForwardPendingLongTap() {
   if (drag_source_window_ && drag_source_window_->delegate()) {
     drag_source_window_->delegate()->OnGestureEvent(pending_long_tap_.get());
     DispatchGestureEndToWindow(drag_source_window_);
   }
   pending_long_tap_.reset();
   if (drag_source_window_)
     drag_source_window_->RemoveObserver(this);
   drag_source_window_ = NULL;
 }
 
 void DragDropController::Cleanup() {
   if (drag_window_)
     drag_window_->RemoveObserver(this);
   drag_window_ = NULL;
   drag_data_ = NULL;
   // Cleanup can be called again while deleting DragDropTracker, so delete
   // the pointer with a local variable to avoid double free.
   std::unique_ptr<ash::DragDropTracker> holder = std::move(drag_drop_tracker_);
 }
 
 }  // namespace ash