clang-format all of //ash

ash/touch/touch_hud_debug.cc

 // Copyright 2013 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/touch/touch_hud_debug.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 21 matching lines @@
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
 #include "ui/events/devices/x11/device_data_manager_x11.h"  // nogncheck
 #endif
 
 namespace ash {
 
 const int kPointRadius = 20;
 const SkColor kColors[] = {
-  SK_ColorYELLOW,
-  SK_ColorGREEN,
-  SK_ColorRED,
-  SK_ColorBLUE,
-  SK_ColorGRAY,
-  SK_ColorMAGENTA,
-  SK_ColorCYAN,
-  SK_ColorWHITE,
-  SK_ColorBLACK,
-  SkColorSetRGB(0xFF, 0x8C, 0x00),
-  SkColorSetRGB(0x8B, 0x45, 0x13),
-  SkColorSetRGB(0xFF, 0xDE, 0xAD),
+    SK_ColorYELLOW,
+    SK_ColorGREEN,
+    SK_ColorRED,
+    SK_ColorBLUE,
+    SK_ColorGRAY,
+    SK_ColorMAGENTA,
+    SK_ColorCYAN,
+    SK_ColorWHITE,
+    SK_ColorBLACK,
+    SkColorSetRGB(0xFF, 0x8C, 0x00),
+    SkColorSetRGB(0x8B, 0x45, 0x13),
+    SkColorSetRGB(0xFF, 0xDE, 0xAD),
 };
 const int kAlpha = 0x60;
 const int kMaxPaths = arraysize(kColors);
 const int kReducedScale = 10;
 
 const char* GetTouchEventLabel(ui::EventType type) {
   switch (type) {
     case ui::ET_UNKNOWN:
       return " ";
     case ui::ET_TOUCH_PRESSED:
@@ skipping 71 matching lines @@
 // A TouchTrace keeps track of all the touch events of a single touch point
 // (starting from a touch-press and ending at a touch-release or touch-cancel).
 class TouchTrace {
  public:
   typedef std::vector<TouchPointLog>::iterator iterator;
   typedef std::vector<TouchPointLog>::const_iterator const_iterator;
   typedef std::vector<TouchPointLog>::reverse_iterator reverse_iterator;
   typedef std::vector<TouchPointLog>::const_reverse_iterator
       const_reverse_iterator;
 
-  TouchTrace() {
-  }
+  TouchTrace() {}
 
   void AddTouchPoint(const ui::TouchEvent& touch) {
     log_.push_back(TouchPointLog(touch));
   }
 
   const std::vector<TouchPointLog>& log() const { return log_; }
 
   bool active() const {
     return !log_.empty() && log_.back().type != ui::ET_TOUCH_RELEASED &&
-        log_.back().type != ui::ET_TOUCH_CANCELLED;
+           log_.back().type != ui::ET_TOUCH_CANCELLED;
   }
 
   // Returns a list containing data from all events for the touch point.
   std::unique_ptr<base::ListValue> GetAsList() const {
     std::unique_ptr<base::ListValue> list(new base::ListValue());
     for (const_iterator i = log_.begin(); i != log_.end(); ++i)
       list->Append((*i).GetAsDictionary());
     return list;
   }
 
-  void Reset() {
-    log_.clear();
-  }
+  void Reset() { log_.clear(); }
 
  private:
   std::vector<TouchPointLog> log_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchTrace);
 };
 
 // A TouchLog keeps track of all touch events of all touch points.
 class TouchLog {
  public:
-  TouchLog() : next_trace_index_(0) {
-  }
+  TouchLog() : next_trace_index_(0) {}
 
   void AddTouchPoint(const ui::TouchEvent& touch) {
     if (touch.type() == ui::ET_TOUCH_PRESSED)
       StartTrace(touch);
     AddToTrace(touch);
   }
 
   void Reset() {
     next_trace_index_ = 0;
     for (int i = 0; i < kMaxPaths; ++i)
       traces_[i].Reset();
   }
 
   std::unique_ptr<base::ListValue> GetAsList() const {
     std::unique_ptr<base::ListValue> list(new base::ListValue());
     for (int i = 0; i < kMaxPaths; ++i) {
       if (!traces_[i].log().empty())
         list->Append(traces_[i].GetAsList());
     }
     return list;
   }
 
   int GetTraceIndex(int touch_id) const {
     return touch_id_to_trace_index_.at(touch_id);
   }
 
-  const TouchTrace* traces() const {
-    return traces_;
-  }
+  const TouchTrace* traces() const { return traces_; }
 
  private:
   void StartTrace(const ui::TouchEvent& touch) {
     // Find the first inactive spot; otherwise, overwrite the one
     // |next_trace_index_| is pointing to.
     int old_trace_index = next_trace_index_;
     do {
       if (!traces_[next_trace_index_].active())
         break;
       next_trace_index_ = (next_trace_index_ + 1) % kMaxPaths;
@@ skipping 15 matching lines @@
 
   std::map<int, int> touch_id_to_trace_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchLog);
 };
 
 // TouchHudCanvas draws touch traces in |FULLSCREEN| and |REDUCED_SCALE| modes.
 class TouchHudCanvas : public views::View {
  public:
   explicit TouchHudCanvas(const TouchLog& touch_log)
-      : touch_log_(touch_log),
-        scale_(1) {
+      : touch_log_(touch_log), scale_(1) {
     SetPaintToLayer(true);
     layer()->SetFillsBoundsOpaquely(false);
 
     paint_.setStyle(SkPaint::kFill_Style);
   }
 
   ~TouchHudCanvas() override {}
 
   void SetScale(int scale) {
     if (scale_ == scale)
@@ skipping 75 matching lines @@
 
   views::View* content = widget()->GetContentsView();
 
   canvas_ = new TouchHudCanvas(*touch_log_);
   content->AddChildView(canvas_);
 
   const gfx::Size& display_size = display.size();
   canvas_->SetSize(display_size);
 
   label_container_ = new views::View;
-  label_container_->SetLayoutManager(new views::BoxLayout(
-      views::BoxLayout::kVertical, 0, 0, 0));
+  label_container_->SetLayoutManager(
+      new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
 
   for (int i = 0; i < kMaxTouchPoints; ++i) {
     touch_labels_[i] = new views::Label;
     touch_labels_[i]->SetBackgroundColor(SkColorSetARGB(0, 255, 255, 255));
     touch_labels_[i]->SetShadows(gfx::ShadowValues(
         1, gfx::ShadowValue(gfx::Vector2d(1, 1), 0, SK_ColorWHITE)));
     label_container_->AddChildView(touch_labels_[i]);
   }
   label_container_->SetX(0);
   label_container_->SetY(display_size.height() / kReducedScale);
   label_container_->SetSize(label_container_->GetPreferredSize());
   label_container_->SetVisible(false);
   content->AddChildView(label_container_);
 }
 
-TouchHudDebug::~TouchHudDebug() {
-}
+TouchHudDebug::~TouchHudDebug() {}
 
 // static
 std::unique_ptr<base::DictionaryValue> TouchHudDebug::GetAllAsDictionary() {
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   aura::Window::Windows roots = Shell::GetInstance()->GetAllRootWindows();
   for (aura::Window::Windows::iterator iter = roots.begin();
-      iter != roots.end(); ++iter) {
+       iter != roots.end(); ++iter) {
     RootWindowController* controller = GetRootWindowController(*iter);
     TouchHudDebug* hud = controller->touch_hud_debug();
     if (hud) {
       std::unique_ptr<base::ListValue> list = hud->GetLogAsList();
       if (!list->empty())
         value->Set(base::Int64ToString(hud->display_id()), list.release());
     }
   }
   return value;
 }
@@ skipping 54 matching lines @@
   int trace_index = touch_log_->GetTraceIndex(index);
   const TouchTrace& trace = touch_log_->traces()[trace_index];
   TouchTrace::const_reverse_iterator point = trace.log().rbegin();
   ui::EventType touch_status = point->type;
   float touch_radius = std::max(point->radius_x, point->radius_y);
   while (point != trace.log().rend() && point->type == ui::ET_TOUCH_CANCELLED)
     point++;
   DCHECK(point != trace.log().rend());
   gfx::Point touch_position = point->location;
 
-  std::string string = base::StringPrintf("%2d: %s %s (%.4f)",
-                                          index,
-                                          GetTouchEventLabel(touch_status),
-                                          touch_position.ToString().c_str(),
-                                          touch_radius);
+  std::string string = base::StringPrintf(
+      "%2d: %s %s (%.4f)", index, GetTouchEventLabel(touch_status),
+      touch_position.ToString().c_str(), touch_radius);
   touch_labels_[index]->SetText(base::UTF8ToUTF16(string));
 }
 
 void TouchHudDebug::OnTouchEvent(ui::TouchEvent* event) {
   if (event->touch_id() >= kMaxTouchPoints)
     return;
 
   touch_log_->AddTouchPoint(*event);
   canvas_->TouchPointAdded(event->touch_id());
   UpdateTouchPointLabel(event->touch_id());
@@ skipping 15 matching lines @@
     RootWindowController* controller) {
   controller->set_touch_hud_debug(this);
 }
 
 void TouchHudDebug::UnsetHudForRootWindowController(
     RootWindowController* controller) {
   controller->set_touch_hud_debug(NULL);
 }
 
 }  // namespace ash