clang-format all of //ash

ash/drag_drop/drag_drop_controller_unittest.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 "ash/drag_drop/drag_drop_tracker.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
@@ skipping 23 matching lines @@
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace test {
 
 namespace {
 
 // A simple view that makes sure RunShellDrag is invoked on mouse drag.
 class DragTestView : public views::View {
  public:
-  DragTestView() : views::View() {
-    Reset();
-  }
+  DragTestView() : views::View() { Reset(); }
 
   void Reset() {
     num_drag_enters_ = 0;
     num_drag_exits_ = 0;
     num_drag_updates_ = 0;
     num_drops_ = 0;
     drag_done_received_ = false;
     long_tap_received_ = false;
   }
 
@@ skipping 63 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DragTestView);
 };
 
 class CompletableLinearAnimation : public gfx::LinearAnimation {
  public:
   CompletableLinearAnimation(int duration,
                              int frame_rate,
                              gfx::AnimationDelegate* delegate)
       : gfx::LinearAnimation(duration, frame_rate, delegate),
-        duration_(duration) {
-  }
+        duration_(duration) {}
 
   void Complete() {
     Step(start_time() + base::TimeDelta::FromMilliseconds(duration_));
   }
 
  private:
   int duration_;
 };
 
 class TestDragDropController : public DragDropController {
@@ skipping 54 matching lines @@
   bool drag_canceled_;
   base::string16 drag_string_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestDragDropController);
 };
 
 class TestNativeWidgetAura : public views::NativeWidgetAura {
  public:
   explicit TestNativeWidgetAura(views::internal::NativeWidgetDelegate* delegate)
-      : NativeWidgetAura(delegate),
-        check_if_capture_lost_(false) {
-  }
+      : NativeWidgetAura(delegate), check_if_capture_lost_(false) {}
 
-  void set_check_if_capture_lost(bool value) {
-    check_if_capture_lost_ = value;
-  }
+  void set_check_if_capture_lost(bool value) { check_if_capture_lost_ = value; }
 
   void OnCaptureLost() override {
     DCHECK(!check_if_capture_lost_);
     views::NativeWidgetAura::OnCaptureLost();
   }
 
  private:
   bool check_if_capture_lost_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNativeWidgetAura);
 };
 
 // TODO(sky): this is for debugging, remove when track down failure.
 void SetCheckIfCaptureLost(views::Widget* widget, bool value) {
-  // On Windows, the DCHECK triggers when running on bot or locally through RDP,
-  // but not when logged in locally.
+// On Windows, the DCHECK triggers when running on bot or locally through RDP,
+// but not when logged in locally.
 #if !defined(OS_WIN)
-  static_cast<TestNativeWidgetAura*>(widget->native_widget())->
-      set_check_if_capture_lost(value);
+  static_cast<TestNativeWidgetAura*>(widget->native_widget())
+      ->set_check_if_capture_lost(value);
 #endif
 }
 
 views::Widget* CreateNewWidget() {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
   params.accept_events = true;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = Shell::GetPrimaryRootWindow();
@@ skipping 14 matching lines @@
   contents_view->AddChildView(view);
   view->SetBounds(contents_view->width(), 0, 100, 100);
   gfx::Rect contents_view_bounds = contents_view->bounds();
   contents_view_bounds.Union(view->bounds());
   contents_view->SetBoundsRect(contents_view_bounds);
   widget->SetBounds(contents_view_bounds);
 }
 
 void DispatchGesture(ui::EventType gesture_type, gfx::Point location) {
   ui::GestureEventDetails event_details(gesture_type);
-  ui::GestureEvent gesture_event(
-      location.x(), location.y(), 0, ui::EventTimeForNow(), event_details);
+  ui::GestureEvent gesture_event(location.x(), location.y(), 0,
+                                 ui::EventTimeForNow(), event_details);
   ui::EventSource* event_source =
       Shell::GetPrimaryRootWindow()->GetHost()->GetEventSource();
   ui::EventSourceTestApi event_source_test(event_source);
   ui::EventDispatchDetails details =
       event_source_test.SendEventToProcessor(&gesture_event);
   CHECK(!details.dispatcher_destroyed);
 }
 
 }  // namespace
 
@@ skipping 13 matching lines @@
   void TearDown() override {
     aura::client::SetDragDropClient(Shell::GetPrimaryRootWindow(), NULL);
     drag_drop_controller_.reset();
     AshTestBase::TearDown();
   }
 
   void UpdateDragData(ui::OSExchangeData* data) {
     drag_drop_controller_->drag_data_ = data;
   }
 
-  aura::Window* GetDragWindow() {
-    return drag_drop_controller_->drag_window_;
-  }
+  aura::Window* GetDragWindow() { return drag_drop_controller_->drag_window_; }
 
   aura::Window* GetDragSourceWindow() {
     return drag_drop_controller_->drag_source_window_;
   }
 
   void SetDragSourceWindow(aura::Window* drag_source_window) {
     drag_drop_controller_->drag_source_window_ = drag_source_window;
     drag_source_window->AddObserver(drag_drop_controller_.get());
   }
 
   aura::Window* GetDragImageWindow() {
-    return drag_drop_controller_->drag_image_.get() ?
-        drag_drop_controller_->drag_image_->GetWidget()->GetNativeWindow() :
-        NULL;
+    return drag_drop_controller_->drag_image_.get()
+               ? drag_drop_controller_->drag_image_->GetWidget()
+                     ->GetNativeWindow()
+               : NULL;
   }
 
   DragDropTracker* drag_drop_tracker() {
     return drag_drop_controller_->drag_drop_tracker_.get();
   }
 
   void CompleteCancelAnimation() {
     CompletableLinearAnimation* animation =
         static_cast<CompletableLinearAnimation*>(
             drag_drop_controller_->cancel_animation_.get());
@@ skipping 39 matching lines @@
     generator.MoveMouseBy(0, 1);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_view->num_drag_updates_);
+            drag_view->num_drag_updates_);
   EXPECT_EQ(1, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 TEST_F(DragDropControllerTest, DragDropWithZeroDragUpdates) {
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
   ui::OSExchangeData data;
@@ skipping 12 matching lines @@
       UpdateDragData(&data);
     generator.MoveMouseBy(0, 1);
   }
 
   UpdateDragData(&data);
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold() + 1,
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
 
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold() + 1,
-      drag_view->num_drag_updates_);
+            drag_view->num_drag_updates_);
   EXPECT_EQ(1, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 // TODO(win_aura) http://crbug.com/154081
 #if defined(OS_WIN)
-#define MAYBE_DragDropInMultipleViewsSingleWidgetTest DISABLED_DragDropInMultipleViewsSingleWidgetTest
+#define MAYBE_DragDropInMultipleViewsSingleWidgetTest \
+  DISABLED_DragDropInMultipleViewsSingleWidgetTest
 #else
-#define MAYBE_DragDropInMultipleViewsSingleWidgetTest DragDropInMultipleViewsSingleWidgetTest
+#define MAYBE_DragDropInMultipleViewsSingleWidgetTest \
+  DragDropInMultipleViewsSingleWidgetTest
 #endif
 TEST_F(DragDropControllerTest, MAYBE_DragDropInMultipleViewsSingleWidgetTest) {
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view1 = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view1);
   DragTestView* drag_view2 = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view2);
 
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
@@ skipping 14 matching lines @@
     generator.MoveMouseBy(1, 0);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view1->HorizontalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view1->num_drag_enters_);
-  int num_expected_updates = drag_view1->bounds().width() -
-      drag_view1->bounds().CenterPoint().x() - 2;
+  int num_expected_updates =
+      drag_view1->bounds().width() - drag_view1->bounds().CenterPoint().x() - 2;
   EXPECT_EQ(num_expected_updates - drag_view1->HorizontalDragThreshold(),
-      drag_view1->num_drag_updates_);
+            drag_view1->num_drag_updates_);
   EXPECT_EQ(0, drag_view1->num_drops_);
   EXPECT_EQ(1, drag_view1->num_drag_exits_);
   EXPECT_TRUE(drag_view1->drag_done_received_);
 
   EXPECT_EQ(1, drag_view2->num_drag_enters_);
   num_expected_updates = num_drags - num_expected_updates - 1;
   EXPECT_EQ(num_expected_updates, drag_view2->num_drag_updates_);
   EXPECT_EQ(1, drag_view2->num_drops_);
   EXPECT_EQ(0, drag_view2->num_drag_exits_);
   EXPECT_FALSE(drag_view2->drag_done_received_);
 }
 
 // TODO(win_aura) http://crbug.com/154081
 #if defined(OS_WIN)
-#define MAYBE_DragDropInMultipleViewsMultipleWidgetsTest DISABLED_DragDropInMultipleViewsMultipleWidgetsTest
+#define MAYBE_DragDropInMultipleViewsMultipleWidgetsTest \
+  DISABLED_DragDropInMultipleViewsMultipleWidgetsTest
 #else
-#define MAYBE_DragDropInMultipleViewsMultipleWidgetsTest DragDropInMultipleViewsMultipleWidgetsTest
+#define MAYBE_DragDropInMultipleViewsMultipleWidgetsTest \
+  DragDropInMultipleViewsMultipleWidgetsTest
 #endif
-TEST_F(DragDropControllerTest, MAYBE_DragDropInMultipleViewsMultipleWidgetsTest) {
+TEST_F(DragDropControllerTest,
+       MAYBE_DragDropInMultipleViewsMultipleWidgetsTest) {
   std::unique_ptr<views::Widget> widget1(CreateNewWidget());
   DragTestView* drag_view1 = new DragTestView;
   AddViewToWidgetAndResize(widget1.get(), drag_view1);
   std::unique_ptr<views::Widget> widget2(CreateNewWidget());
   DragTestView* drag_view2 = new DragTestView;
   AddViewToWidgetAndResize(widget2.get(), drag_view2);
   gfx::Rect widget1_bounds = widget1->GetClientAreaBoundsInScreen();
   gfx::Rect widget2_bounds = widget2->GetClientAreaBoundsInScreen();
   widget2->SetBounds(gfx::Rect(widget1_bounds.width(), 0,
-      widget2_bounds.width(), widget2_bounds.height()));
+                               widget2_bounds.width(),
+                               widget2_bounds.height()));
 
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget1->GetNativeView());
   generator.PressLeftButton();
 
   int num_drags = drag_view1->width();
   for (int i = 0; i < num_drags; ++i) {
     // Because we are not doing a blocking drag and drop, the original
     // OSDragExchangeData object is lost as soon as we return from the drag
     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
     // drag_data_ to a fake drag data object that we created.
     if (i > 0)
       UpdateDragData(&data);
     generator.MoveMouseBy(1, 0);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view1->HorizontalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view1->num_drag_enters_);
-  int num_expected_updates = drag_view1->bounds().width() -
-      drag_view1->bounds().CenterPoint().x() - 2;
+  int num_expected_updates =
+      drag_view1->bounds().width() - drag_view1->bounds().CenterPoint().x() - 2;
   EXPECT_EQ(num_expected_updates - drag_view1->HorizontalDragThreshold(),
-      drag_view1->num_drag_updates_);
+            drag_view1->num_drag_updates_);
   EXPECT_EQ(0, drag_view1->num_drops_);
   EXPECT_EQ(1, drag_view1->num_drag_exits_);
   EXPECT_TRUE(drag_view1->drag_done_received_);
 
   EXPECT_EQ(1, drag_view2->num_drag_enters_);
   num_expected_updates = num_drags - num_expected_updates - 1;
   EXPECT_EQ(num_expected_updates, drag_view2->num_drag_updates_);
   EXPECT_EQ(1, drag_view2->num_drops_);
   EXPECT_EQ(0, drag_view2->num_drag_exits_);
   EXPECT_FALSE(drag_view2->drag_done_received_);
 }
 
 // TODO(win_aura) http://crbug.com/154081
 #if defined(OS_WIN)
-#define MAYBE_ViewRemovedWhileInDragDropTest DISABLED_ViewRemovedWhileInDragDropTest
+#define MAYBE_ViewRemovedWhileInDragDropTest \
+  DISABLED_ViewRemovedWhileInDragDropTest
 #else
 #define MAYBE_ViewRemovedWhileInDragDropTest ViewRemovedWhileInDragDropTest
 #endif
 TEST_F(DragDropControllerTest, MAYBE_ViewRemovedWhileInDragDropTest) {
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   std::unique_ptr<DragTestView> drag_view(new DragTestView);
   AddViewToWidgetAndResize(widget.get(), drag_view.get());
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
 
@@ skipping 23 matching lines @@
     generator.MoveMouseBy(0, 1);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags_1 + num_drags_2 - 1 - drag_view->VerticalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(num_drags_1 - 1 - drag_view->VerticalDragThreshold(),
-      drag_view->num_drag_updates_);
+            drag_view->num_drag_updates_);
   EXPECT_EQ(0, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 TEST_F(DragDropControllerTest, DragLeavesClipboardAloneTest) {
   ui::Clipboard* cb = ui::Clipboard::GetForCurrentThread();
   std::string clip_str("I am on the clipboard");
   {
     // We first copy some text to the clipboard.
     ui::ScopedClipboardWriter scw(ui::CLIPBOARD_TYPE_COPY_PASTE);
     scw.WriteText(base::ASCIIToUTF16(clip_str));
   }
   EXPECT_TRUE(cb->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
-      ui::CLIPBOARD_TYPE_COPY_PASTE));
+                                    ui::CLIPBOARD_TYPE_COPY_PASTE));
 
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget->GetNativeView());
   ui::OSExchangeData data;
   std::string data_str("I am being dragged");
   data.SetString(base::ASCIIToUTF16(data_str));
 
   generator.PressLeftButton();
   generator.MoveMouseBy(0, drag_view->VerticalDragThreshold() + 1);
 
   // Execute any scheduled draws to process deferred mouse events.
   RunAllPendingInMessageLoop();
 
   // Verify the clipboard contents haven't changed
   std::string result;
   EXPECT_TRUE(cb->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
-      ui::CLIPBOARD_TYPE_COPY_PASTE));
+                                    ui::CLIPBOARD_TYPE_COPY_PASTE));
   cb->ReadAsciiText(ui::CLIPBOARD_TYPE_COPY_PASTE, &result);
   EXPECT_EQ(clip_str, result);
   // Destory the clipboard here because ash doesn't delete it.
   // crbug.com/158150.
   ui::Clipboard::DestroyClipboardForCurrentThread();
 }
 
 TEST_F(DragDropControllerTest, WindowDestroyedDuringDragDrop) {
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
@@ skipping 59 matching lines @@
     if (i > 0)
       UpdateDragData(&data);
     generator.MoveMouseBy(0, 1);
 
     // We send a unexpected mouse move event. Note that we cannot use
     // EventGenerator since it implicitly turns these into mouse drag events.
     // The DragDropController should simply ignore these events.
     gfx::Point mouse_move_location = drag_view->bounds().CenterPoint();
     ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED, mouse_move_location,
                               mouse_move_location, ui::EventTimeForNow(), 0, 0);
-    ui::EventDispatchDetails details = Shell::GetPrimaryRootWindow()->
-        GetHost()->event_processor()->OnEventFromSource(&mouse_move);
+    ui::EventDispatchDetails details = Shell::GetPrimaryRootWindow()
+                                           ->GetHost()
+                                           ->event_processor()
+                                           ->OnEventFromSource(&mouse_move);
     ASSERT_FALSE(details.dispatcher_destroyed);
   }
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_view->num_drag_updates_);
+            drag_view->num_drag_updates_);
   EXPECT_EQ(1, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 // TODO(win_aura) http://crbug.com/154081
 #if defined(OS_WIN)
-#define MAYBE_PressingEscapeCancelsDragDrop DISABLED_PressingEscapeCancelsDragDrop
+#define MAYBE_PressingEscapeCancelsDragDrop \
+  DISABLED_PressingEscapeCancelsDragDrop
 #define MAYBE_CaptureLostCancelsDragDrop DISABLED_CaptureLostCancelsDragDrop
 #else
 #define MAYBE_PressingEscapeCancelsDragDrop PressingEscapeCancelsDragDrop
 #define MAYBE_CaptureLostCancelsDragDrop CaptureLostCancelsDragDrop
 #endif
 TEST_F(DragDropControllerTest, MAYBE_PressingEscapeCancelsDragDrop) {
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
   ui::OSExchangeData data;
@@ skipping 13 matching lines @@
     generator.MoveMouseBy(0, 1);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   generator.PressKey(ui::VKEY_ESCAPE, 0);
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_FALSE(drag_drop_controller_->drop_received_);
   EXPECT_TRUE(drag_drop_controller_->drag_canceled_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_view->num_drag_updates_);
+            drag_view->num_drag_updates_);
   EXPECT_EQ(0, drag_view->num_drops_);
   EXPECT_EQ(1, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 TEST_F(DragDropControllerTest, MAYBE_CaptureLostCancelsDragDrop) {
   std::unique_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
   ui::OSExchangeData data;
@@ skipping 12 matching lines @@
       UpdateDragData(&data);
     generator.MoveMouseBy(0, 1);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
   // Make sure the capture window won't handle mouse events.
   aura::Window* capture_window = drag_drop_tracker()->capture_window();
   ASSERT_TRUE(capture_window);
   EXPECT_EQ("0x0", capture_window->bounds().size().ToString());
-  EXPECT_EQ(NULL,
-            capture_window->GetEventHandlerForPoint(gfx::Point()));
-  EXPECT_EQ(NULL,
-            capture_window->GetTopWindowContainingPoint(gfx::Point()));
+  EXPECT_EQ(NULL, capture_window->GetEventHandlerForPoint(gfx::Point()));
+  EXPECT_EQ(NULL, capture_window->GetTopWindowContainingPoint(gfx::Point()));
 
-  aura::client::GetCaptureClient(widget->GetNativeView()->GetRootWindow())->
-      SetCapture(NULL);
+  aura::client::GetCaptureClient(widget->GetNativeView()->GetRootWindow())
+      ->SetCapture(NULL);
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_drop_controller_->num_drag_updates_);
+            drag_drop_controller_->num_drag_updates_);
   EXPECT_FALSE(drag_drop_controller_->drop_received_);
   EXPECT_TRUE(drag_drop_controller_->drag_canceled_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(num_drags - 1 - drag_view->VerticalDragThreshold(),
-      drag_view->num_drag_updates_);
+            drag_view->num_drag_updates_);
   EXPECT_EQ(0, drag_view->num_drops_);
   EXPECT_EQ(1, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 TEST_F(DragDropControllerTest, TouchDragDropInMultipleWindows) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchDragDrop);
   std::unique_ptr<views::Widget> widget1(CreateNewWidget());
   DragTestView* drag_view1 = new DragTestView;
   AddViewToWidgetAndResize(widget1.get(), drag_view1);
   std::unique_ptr<views::Widget> widget2(CreateNewWidget());
   DragTestView* drag_view2 = new DragTestView;
   AddViewToWidgetAndResize(widget2.get(), drag_view2);
   gfx::Rect widget1_bounds = widget1->GetClientAreaBoundsInScreen();
   gfx::Rect widget2_bounds = widget2->GetClientAreaBoundsInScreen();
   widget2->SetBounds(gfx::Rect(widget1_bounds.width(), 0,
-      widget2_bounds.width(), widget2_bounds.height()));
+                               widget2_bounds.width(),
+                               widget2_bounds.height()));
 
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget1->GetNativeView());
   generator.PressTouch();
   gfx::Point point = gfx::Rect(drag_view1->bounds()).CenterPoint();
   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
   // Because we are not doing a blocking drag and drop, the original
@@ skipping 10 matching lines @@
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   DispatchGesture(ui::ET_GESTURE_SCROLL_END, gesture_location);
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags, drag_drop_controller_->num_drag_updates_);
   EXPECT_TRUE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
-      drag_drop_controller_->drag_string_);
+            drag_drop_controller_->drag_string_);
 
   EXPECT_EQ(1, drag_view1->num_drag_enters_);
-  int num_expected_updates = drag_view1->bounds().width() -
-      drag_view1->bounds().CenterPoint().x() - 1;
+  int num_expected_updates =
+      drag_view1->bounds().width() - drag_view1->bounds().CenterPoint().x() - 1;
   EXPECT_EQ(num_expected_updates, drag_view1->num_drag_updates_);
   EXPECT_EQ(0, drag_view1->num_drops_);
   EXPECT_EQ(1, drag_view1->num_drag_exits_);
   EXPECT_TRUE(drag_view1->drag_done_received_);
 
   EXPECT_EQ(1, drag_view2->num_drag_enters_);
   num_expected_updates = num_drags - num_expected_updates;
   EXPECT_EQ(num_expected_updates, drag_view2->num_drag_updates_);
   EXPECT_EQ(1, drag_view2->num_drops_);
   EXPECT_EQ(0, drag_view2->num_drag_exits_);
@@ skipping 80 matching lines @@
        iter != root_windows.end(); ++iter) {
     aura::client::SetDragDropClient(*iter, drag_drop_controller_.get());
   }
 
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
   {
     std::unique_ptr<views::Widget> widget(CreateNewWidget());
     aura::Window* window = widget->GetNativeWindow();
     drag_drop_controller_->StartDragAndDrop(
-        data,
-        window->GetRootWindow(),
-        window,
-        gfx::Point(5, 5),
+        data, window->GetRootWindow(), window, gfx::Point(5, 5),
         ui::DragDropTypes::DRAG_MOVE,
         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
 
     DragImageWindowObserver observer;
     ASSERT_TRUE(GetDragImageWindow());
     GetDragImageWindow()->AddObserver(&observer);
 
     {
       ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::Point(200, 0),
                        gfx::Point(200, 0), ui::EventTimeForNow(), ui::EF_NONE,
@@ skipping 10 matching lines @@
     drag_drop_controller_->DragCancel();
     CompleteCancelAnimation();
 
     EXPECT_EQ("5,5", observer.window_location_on_destroying().ToString());
   }
 
   {
     std::unique_ptr<views::Widget> widget(CreateNewWidget());
     aura::Window* window = widget->GetNativeWindow();
     drag_drop_controller_->StartDragAndDrop(
-        data,
-        window->GetRootWindow(),
-        window,
-        gfx::Point(405, 405),
+        data, window->GetRootWindow(), window, gfx::Point(405, 405),
         ui::DragDropTypes::DRAG_MOVE,
         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
     DragImageWindowObserver observer;
     ASSERT_TRUE(GetDragImageWindow());
     GetDragImageWindow()->AddObserver(&observer);
 
     {
       ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::Point(600, 0),
                        gfx::Point(600, 0), ui::EventTimeForNow(), ui::EF_NONE,
                        ui::EF_NONE);
@@ skipping 59 matching lines @@
             drag_drop_controller_->drag_string_);
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(2, drag_view->num_drag_updates_);
   EXPECT_EQ(1, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 }  // namespace test
 }  // namespace ash