clang-format all of //ash

ash/host/ash_window_tree_host_x11.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"
 
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
@@ skipping 26 matching lines @@
     : WindowTreeHostX11(initial_bounds), transformer_helper_(this) {
   transformer_helper_.Init();
   aura::Env::GetInstance()->AddObserver(this);
 }
 
 AshWindowTreeHostX11::~AshWindowTreeHostX11() {
   aura::Env::GetInstance()->RemoveObserver(this);
   UnConfineCursor();
 }
 
-void AshWindowTreeHostX11::ToggleFullScreen() { NOTIMPLEMENTED(); }
+void AshWindowTreeHostX11::ToggleFullScreen() {
+  NOTIMPLEMENTED();
+}
 
 bool AshWindowTreeHostX11::ConfineCursorToRootWindow() {
 #if XFIXES_MAJOR >= 5
   DCHECK(!pointer_barriers_.get());
   if (pointer_barriers_)
     return false;
   pointer_barriers_.reset(new XID[4]);
   gfx::Rect barrier(bounds());
   barrier.Inset(transformer_helper_.GetHostInsets());
   // Horizontal, top barriers.
-  pointer_barriers_[0] = XFixesCreatePointerBarrier(xdisplay(),
-                                                    x_root_window(),
-                                                    barrier.x(),
-                                                    barrier.y(),
-                                                    barrier.right(),
-                                                    barrier.y(),
-                                                    BarrierPositiveY,
-                                                    0,
-                                                    XIAllDevices);
+  pointer_barriers_[0] = XFixesCreatePointerBarrier(
+      xdisplay(), x_root_window(), barrier.x(), barrier.y(), barrier.right(),
+      barrier.y(), BarrierPositiveY, 0, XIAllDevices);
   // Horizontal, bottom barriers.
-  pointer_barriers_[1] = XFixesCreatePointerBarrier(xdisplay(),
-                                                    x_root_window(),
-                                                    barrier.x(),
-                                                    barrier.bottom(),
-                                                    barrier.right(),
-                                                    barrier.bottom(),
-                                                    BarrierNegativeY,
-                                                    0,
-                                                    XIAllDevices);
+  pointer_barriers_[1] = XFixesCreatePointerBarrier(
+      xdisplay(), x_root_window(), barrier.x(), barrier.bottom(),
+      barrier.right(), barrier.bottom(), BarrierNegativeY, 0, XIAllDevices);
   // Vertical, left  barriers.
-  pointer_barriers_[2] = XFixesCreatePointerBarrier(xdisplay(),
-                                                    x_root_window(),
-                                                    barrier.x(),
-                                                    barrier.y(),
-                                                    barrier.x(),
-                                                    barrier.bottom(),
-                                                    BarrierPositiveX,
-                                                    0,
-                                                    XIAllDevices);
+  pointer_barriers_[2] = XFixesCreatePointerBarrier(
+      xdisplay(), x_root_window(), barrier.x(), barrier.y(), barrier.x(),
+      barrier.bottom(), BarrierPositiveX, 0, XIAllDevices);
   // Vertical, right barriers.
-  pointer_barriers_[3] = XFixesCreatePointerBarrier(xdisplay(),
-                                                    x_root_window(),
-                                                    barrier.right(),
-                                                    barrier.y(),
-                                                    barrier.right(),
-                                                    barrier.bottom(),
-                                                    BarrierNegativeX,
-                                                    0,
-                                                    XIAllDevices);
+  pointer_barriers_[3] = XFixesCreatePointerBarrier(
+      xdisplay(), x_root_window(), barrier.right(), barrier.y(),
+      barrier.right(), barrier.bottom(), BarrierNegativeX, 0, XIAllDevices);
 #endif
   return true;
 }
 
 void AshWindowTreeHostX11::UnConfineCursor() {
 #if XFIXES_MAJOR >= 5
   if (pointer_barriers_) {
     XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[0]);
     XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[1]);
     XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[2]);
     XFixesDestroyPointerBarrier(xdisplay(), pointer_barriers_[3]);
     pointer_barriers_.reset();
   }
 #endif
 }
 
 void AshWindowTreeHostX11::SetRootWindowTransformer(
     std::unique_ptr<RootWindowTransformer> transformer) {
   transformer_helper_.SetRootWindowTransformer(std::move(transformer));
   if (pointer_barriers_) {
     UnConfineCursor();
     ConfineCursorToRootWindow();
   }
 }
 
 gfx::Insets AshWindowTreeHostX11::GetHostInsets() const {
   return transformer_helper_.GetHostInsets();
 }
 
-aura::WindowTreeHost* AshWindowTreeHostX11::AsWindowTreeHost() { return this; }
+aura::WindowTreeHost* AshWindowTreeHostX11::AsWindowTreeHost() {
+  return this;
+}
 
 void AshWindowTreeHostX11::PrepareForShutdown() {
   // Block the root window from dispatching events because it is weird for a
   // ScreenPositionClient not to be attached to the root window and for
   // ui::EventHandlers to be unable to convert the event's location to screen
   // coordinates.
   window()->SetEventTargeter(
       std::unique_ptr<ui::EventTargeter>(new ui::NullEventTargeter));
 
   if (ui::PlatformEventSource::GetInstance()) {
@@ skipping 49 matching lines @@
 void AshWindowTreeHostX11::OnConfigureNotify() {
   // Always update barrier and mouse location because |bounds_| might
   // have already been updated in |SetBounds|.
   if (pointer_barriers_) {
     UnConfineCursor();
     ConfineCursorToRootWindow();
   }
 }
 
 bool AshWindowTreeHostX11::CanDispatchEvent(const ui::PlatformEvent& event) {
-  if(!WindowTreeHostX11::CanDispatchEvent(event))
+  if (!WindowTreeHostX11::CanDispatchEvent(event))
     return false;
   XEvent* xev = event;
   ui::EventType type = ui::EventTypeFromNative(xev);
   // For touch event, check if the root window is residing on the according
   // touch display.
   switch (type) {
     case ui::ET_TOUCH_MOVED:
     case ui::ET_TOUCH_PRESSED:
     case ui::ET_TOUCH_CANCELLED:
     case ui::ET_TOUCH_RELEASED: {
@@ skipping 48 matching lines @@
   const XIDeviceList& dev_list =
       ui::DeviceListCacheX11::GetInstance()->GetXI2DeviceList(xdisplay());
 
   // Only slave pointer devices could possibly have tap-paused property.
   for (int i = 0; i < dev_list.count; i++) {
     if (dev_list[i].use == XISlavePointer) {
       Atom old_type;
       int old_format;
       unsigned long old_nvalues, bytes;
       unsigned char* data;
-      int result = XIGetProperty(xdisplay(),
-                                 dev_list[i].deviceid,
-                                 prop,
-                                 0,
-                                 0,
-                                 False,
-                                 AnyPropertyType,
-                                 &old_type,
-                                 &old_format,
-                                 &old_nvalues,
-                                 &bytes,
-                                 &data);
+      int result = XIGetProperty(xdisplay(), dev_list[i].deviceid, prop, 0, 0,
+                                 False, AnyPropertyType, &old_type, &old_format,
+                                 &old_nvalues, &bytes, &data);
       if (result != Success)
         continue;
       XFree(data);
-      XIChangeProperty(xdisplay(),
-                       dev_list[i].deviceid,
-                       prop,
-                       XA_INTEGER,
-                       8,
-                       PropModeReplace,
-                       &value,
-                       1);
+      XIChangeProperty(xdisplay(), dev_list[i].deviceid, prop, XA_INTEGER, 8,
+                       PropModeReplace, &value, 1);
     }
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace ash