clang-format all of //ash

ash/host/ash_window_tree_host_x11_unittest.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/host/ash_window_tree_host_x11.h"
 
 #undef None
 #undef Bool
 
 #include "base/sys_info.h"
@@ skipping 66 matching lines @@
     // tests will fail.
     // Fake a ChromeOS running env.
     const char* kLsbRelease = "";
     base::SysInfo::SetChromeOSVersionInfoForTest(kLsbRelease, base::Time());
 #endif
   }
 };
 
 // Fails on ChromeOS valgrind bot. http://crbug.com/499997
 #if defined(OS_CHROMEOS)
-#define MAYBE_DispatchTouchEventToOneRootWindow DISABLED_DispatchTouchEventToOneRootWindow
+#define MAYBE_DispatchTouchEventToOneRootWindow \
+  DISABLED_DispatchTouchEventToOneRootWindow
 #else
-#define MAYBE_DispatchTouchEventToOneRootWindow DispatchTouchEventToOneRootWindow
+#define MAYBE_DispatchTouchEventToOneRootWindow \
+  DispatchTouchEventToOneRootWindow
 #endif
 
 // Send X touch events to one WindowTreeHost. The WindowTreeHost's
 // delegate will get corresponding ui::TouchEvent if the touch events
 // are targeting this WindowTreeHost.
 TEST_F(AshWindowTreeHostX11Test, MAYBE_DispatchTouchEventToOneRootWindow) {
   std::unique_ptr<aura::WindowTreeHostX11> window_tree_host(
       new AshWindowTreeHostX11(gfx::Rect(0, 0, 2560, 1700)));
   window_tree_host->InitHost();
   std::unique_ptr<RootWindowEventHandler> handler(
       new RootWindowEventHandler(window_tree_host.get()));
 
   std::vector<int> devices;
   devices.push_back(0);
   ui::SetUpTouchDevicesForTest(devices);
   std::vector<ui::Valuator> valuators;
 
   EXPECT_EQ(ui::ET_UNKNOWN, handler->last_touch_type());
   EXPECT_EQ(-1, handler->last_touch_id());
 
   ui::ScopedXI2Event scoped_xevent;
   // This touch is out of bounds.
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchBegin, 5, gfx::Point(1500, 2500),
+                               valuators);
   if (window_tree_host->CanDispatchEvent(scoped_xevent))
     window_tree_host->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler->last_touch_type());
   EXPECT_EQ(-1, handler->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler->last_touch_location());
 
   // Following touchs are within bounds and are passed to delegate.
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 1500), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchBegin, 5, gfx::Point(1500, 1500),
+                               valuators);
   if (window_tree_host->CanDispatchEvent(scoped_xevent))
     window_tree_host->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, handler->last_touch_type());
   EXPECT_EQ(0, handler->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 1500), handler->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchUpdate, 5, gfx::Point(1500, 1600), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchUpdate, 5, gfx::Point(1500, 1600),
+                               valuators);
   if (window_tree_host->CanDispatchEvent(scoped_xevent))
     window_tree_host->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, handler->last_touch_type());
   EXPECT_EQ(0, handler->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 1600), handler->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchEnd, 5, gfx::Point(1500, 1600), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchEnd, 5, gfx::Point(1500, 1600),
+                               valuators);
   if (window_tree_host->CanDispatchEvent(scoped_xevent))
     window_tree_host->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, handler->last_touch_type());
   EXPECT_EQ(0, handler->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 1600), handler->last_touch_location());
 
   handler.reset();
 }
 
 // Send X touch events to two WindowTreeHost. The WindowTreeHost which is
@@ skipping 18 matching lines @@
   ui::SetUpTouchDevicesForTest(devices);
   std::vector<ui::Valuator> valuators;
 
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(ui::ET_UNKNOWN, handler2->last_touch_type());
   EXPECT_EQ(-1, handler2->last_touch_id());
 
   // 2 Touch events are targeted at the second WindowTreeHost.
   ui::ScopedXI2Event scoped_xevent;
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 5, gfx::Point(1500, 2500), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchBegin, 5, gfx::Point(1500, 2500),
+                               valuators);
   if (window_tree_host1->CanDispatchEvent(scoped_xevent))
     window_tree_host1->DispatchEvent(scoped_xevent);
   if (window_tree_host2->CanDispatchEvent(scoped_xevent))
     window_tree_host2->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler1->last_touch_location());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, handler2->last_touch_type());
   EXPECT_EQ(0, handler2->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 2500), handler2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchBegin, 6, gfx::Point(1600, 2600), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchBegin, 6, gfx::Point(1600, 2600),
+                               valuators);
   if (window_tree_host1->CanDispatchEvent(scoped_xevent))
     window_tree_host1->DispatchEvent(scoped_xevent);
   if (window_tree_host2->CanDispatchEvent(scoped_xevent))
     window_tree_host2->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler1->last_touch_location());
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, handler2->last_touch_type());
   EXPECT_EQ(1, handler2->last_touch_id());
   EXPECT_EQ(gfx::Point(1600, 2600), handler2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchUpdate, 5, gfx::Point(1500, 2550), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchUpdate, 5, gfx::Point(1500, 2550),
+                               valuators);
   if (window_tree_host1->CanDispatchEvent(scoped_xevent))
     window_tree_host1->DispatchEvent(scoped_xevent);
   if (window_tree_host2->CanDispatchEvent(scoped_xevent))
     window_tree_host2->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler1->last_touch_location());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, handler2->last_touch_type());
   EXPECT_EQ(0, handler2->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 2550), handler2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchUpdate, 6, gfx::Point(1600, 2650), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchUpdate, 6, gfx::Point(1600, 2650),
+                               valuators);
   if (window_tree_host1->CanDispatchEvent(scoped_xevent))
     window_tree_host1->DispatchEvent(scoped_xevent);
   if (window_tree_host2->CanDispatchEvent(scoped_xevent))
     window_tree_host2->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler1->last_touch_location());
   EXPECT_EQ(ui::ET_TOUCH_MOVED, handler2->last_touch_type());
   EXPECT_EQ(1, handler2->last_touch_id());
   EXPECT_EQ(gfx::Point(1600, 2650), handler2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchEnd, 5, gfx::Point(1500, 2550), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchEnd, 5, gfx::Point(1500, 2550),
+                               valuators);
   if (window_tree_host1->CanDispatchEvent(scoped_xevent))
     window_tree_host1->DispatchEvent(scoped_xevent);
   if (window_tree_host2->CanDispatchEvent(scoped_xevent))
     window_tree_host2->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler1->last_touch_location());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, handler2->last_touch_type());
   EXPECT_EQ(0, handler2->last_touch_id());
   EXPECT_EQ(gfx::Point(1500, 2550), handler2->last_touch_location());
 
-  scoped_xevent.InitTouchEvent(
-      0, XI_TouchEnd, 6, gfx::Point(1600, 2650), valuators);
+  scoped_xevent.InitTouchEvent(0, XI_TouchEnd, 6, gfx::Point(1600, 2650),
+                               valuators);
   if (window_tree_host1->CanDispatchEvent(scoped_xevent))
     window_tree_host1->DispatchEvent(scoped_xevent);
   if (window_tree_host2->CanDispatchEvent(scoped_xevent))
     window_tree_host2->DispatchEvent(scoped_xevent);
   EXPECT_EQ(ui::ET_UNKNOWN, handler1->last_touch_type());
   EXPECT_EQ(-1, handler1->last_touch_id());
   EXPECT_EQ(gfx::Point(0, 0), handler1->last_touch_location());
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, handler2->last_touch_type());
   EXPECT_EQ(1, handler2->last_touch_id());
   EXPECT_EQ(gfx::Point(1600, 2650), handler2->last_touch_location());
 
   handler1.reset();
   handler2.reset();
 }
 
 }  // namespace aura