clang-format all of //ash

ash/wm/video_detector.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/wm/video_detector.h"
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_shell.h"
 #include "ash/shell.h"
@@ skipping 27 matching lines @@
     // If the buffer is full, drop the first timestamp.
     if (buffer_size_ == static_cast<size_t>(kMinFramesPerSecond)) {
       buffer_start_ = (buffer_start_ + 1) % kMinFramesPerSecond;
       buffer_size_--;
     }
 
     update_times_[(buffer_start_ + buffer_size_) % kMinFramesPerSecond] = now;
     buffer_size_++;
 
     return buffer_size_ == static_cast<size_t>(kMinFramesPerSecond) &&
-        (now - update_times_[buffer_start_]).InSecondsF() <= 1.0;
+           (now - update_times_[buffer_start_]).InSecondsF() <= 1.0;
   }
 
  private:
   // Circular buffer containing update times of the last (up to
   // |kMinFramesPerSecond|) video-sized updates to this window.
   base::TimeTicks update_times_[kMinFramesPerSecond];
 
   // Index into |update_times_| of the oldest update.
   size_t buffer_start_;
 
   // Number of updates stored in |update_times_|.
   size_t buffer_size_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowInfo);
 };
 
 VideoDetector::VideoDetector()
-    : observer_manager_(this),
-      is_shutting_down_(false) {
+    : observer_manager_(this), is_shutting_down_(false) {
   aura::Env::GetInstance()->AddObserver(this);
   WmShell::Get()->AddShellObserver(this);
 }
 
 VideoDetector::~VideoDetector() {
   WmShell::Get()->RemoveShellObserver(this);
   aura::Env::GetInstance()->RemoveObserver(this);
 }
 
 void VideoDetector::AddObserver(VideoDetectorObserver* observer) {
@@ skipping 31 matching lines @@
 void VideoDetector::OnAppTerminating() {
   // Stop checking video activity once the shutdown
   // process starts. crbug.com/231696.
   is_shutting_down_ = true;
 }
 
 void VideoDetector::MaybeNotifyObservers(aura::Window* window,
                                          base::TimeTicks now) {
   if (!last_observer_notification_time_.is_null() &&
       (now - last_observer_notification_time_).InSecondsF() <
-      kNotifyIntervalSec)
+          kNotifyIntervalSec)
     return;
 
   if (!window->IsVisible())
     return;
 
   gfx::Rect root_bounds = window->GetRootWindow()->bounds();
   if (!window->GetBoundsInRootWindow().Intersects(root_bounds))
     return;
 
   // As a relatively-cheap way to avoid flipping back and forth between
   // fullscreen and non-fullscreen notifications when one video is playing in a
   // fullscreen window and a second video is playing in a non-fullscreen window,
   // report fullscreen video whenever a fullscreen window exists on any desktop
   // regardless of whether the video is actually playing in that window:
   // http://crbug.com/340666
   bool fullscreen_window_exists = false;
   std::vector<aura::Window*> containers =
       Shell::GetContainersFromAllRootWindows(kShellWindowId_DefaultContainer,
                                              NULL);
   for (std::vector<aura::Window*>::const_iterator container =
-       containers.begin(); container != containers.end(); ++container) {
+           containers.begin();
+       container != containers.end(); ++container) {
     const aura::Window::Windows& windows = (*container)->children();
     for (aura::Window::Windows::const_iterator window = windows.begin();
          window != windows.end(); ++window) {
       if (wm::GetWindowState(*window)->IsFullscreen()) {
         fullscreen_window_exists = true;
         break;
       }
     }
   }
 
-  FOR_EACH_OBSERVER(VideoDetectorObserver,
-                    observers_,
+  FOR_EACH_OBSERVER(VideoDetectorObserver, observers_,
                     OnVideoDetected(fullscreen_window_exists));
   last_observer_notification_time_ = now;
 }
 
 }  // namespace ash