clang-format all of //ash

ash/wm/immersive_fullscreen_controller.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/wm/immersive_fullscreen_controller.h"
 
 #include <set>
 
 #include "ash/common/ash_constants.h"
 #include "ash/common/wm/window_state.h"
@@ skipping 231 matching lines @@
       widget_(NULL),
       native_window_(NULL),
       observers_enabled_(false),
       enabled_(false),
       reveal_state_(CLOSED),
       revealed_lock_count_(0),
       mouse_x_when_hit_top_in_screen_(-1),
       gesture_begun_(false),
       animation_(new gfx::SlideAnimation(this)),
       animations_disabled_for_test_(false),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 ImmersiveFullscreenController::~ImmersiveFullscreenController() {
   EnableWindowObservers(false);
 }
 
 void ImmersiveFullscreenController::Init(Delegate* delegate,
                                          views::Widget* widget,
                                          views::View* top_container) {
   delegate_ = delegate;
   top_container_ = top_container;
@@ skipping 44 matching lines @@
     }
   } else {
     // Stop cursor-at-top tracking.
     top_edge_hover_timer_.Stop();
     reveal_state_ = CLOSED;
 
     delegate_->OnImmersiveFullscreenExited();
   }
 
   if (enabled_) {
-    UMA_HISTOGRAM_ENUMERATION("Ash.ImmersiveFullscreen.WindowType",
-                              window_type,
+    UMA_HISTOGRAM_ENUMERATION("Ash.ImmersiveFullscreen.WindowType", window_type,
                               WINDOW_TYPE_COUNT);
   }
 }
 
 bool ImmersiveFullscreenController::IsEnabled() const {
   return enabled_;
 }
 
 bool ImmersiveFullscreenController::IsRevealed() const {
   return enabled_ && reveal_state_ != CLOSED;
@@ skipping 104 matching lines @@
     default:
       break;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::FocusChangeListener overrides:
 
 void ImmersiveFullscreenController::OnWillChangeFocus(
     views::View* focused_before,
-    views::View* focused_now) {
-}
+    views::View* focused_now) {}
 
 void ImmersiveFullscreenController::OnDidChangeFocus(
     views::View* focused_before,
     views::View* focused_now) {
   UpdateFocusRevealedLock();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // views::WidgetObserver overrides:
 
@@ skipping 49 matching lines @@
     aura::Window* transient) {
   bubble_observer_->StopObserving(transient);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ash::ImmersiveRevealedLock::Delegate overrides:
 
 void ImmersiveFullscreenController::LockRevealedState(
     AnimateReveal animate_reveal) {
   ++revealed_lock_count_;
-  Animate animate = (animate_reveal == ANIMATE_REVEAL_YES) ?
-      ANIMATE_FAST : ANIMATE_NO;
+  Animate animate =
+      (animate_reveal == ANIMATE_REVEAL_YES) ? ANIMATE_FAST : ANIMATE_NO;
   MaybeStartReveal(animate);
 }
 
 void ImmersiveFullscreenController::UnlockRevealedState() {
   --revealed_lock_count_;
   DCHECK_GE(revealed_lock_count_, 0);
   if (revealed_lock_count_ == 0) {
     // Always animate ending the reveal fast.
     MaybeEndReveal(ANIMATE_FAST);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private:
 
 void ImmersiveFullscreenController::EnableWindowObservers(bool enable) {
   if (observers_enabled_ == enable)
     return;
   observers_enabled_ = enable;
 
   views::FocusManager* focus_manager = widget_->GetFocusManager();
 
   if (enable) {
     widget_->AddObserver(this);
     focus_manager->AddFocusChangeListener(this);
     Shell::GetInstance()->AddPreTargetHandler(this);
-    ::wm::TransientWindowManager::Get(native_window_)->
-        AddObserver(this);
+    ::wm::TransientWindowManager::Get(native_window_)->AddObserver(this);
 
     RecreateBubbleObserver();
   } else {
     widget_->RemoveObserver(this);
     focus_manager->RemoveFocusChangeListener(this);
     Shell::GetInstance()->RemovePreTargetHandler(this);
-    ::wm::TransientWindowManager::Get(native_window_)->
-        RemoveObserver(this);
+    ::wm::TransientWindowManager::Get(native_window_)->RemoveObserver(this);
 
     // We have stopped observing whether transient children are added or removed
     // to |native_window_|. The set of bubbles that BubbleObserver is observing
     // will become stale really quickly. Destroy BubbleObserver and recreate it
     // when we start observing |native_window_| again.
     bubble_observer_.reset();
 
     animation_->Stop();
   }
 }
@@ skipping 37 matching lines @@
   if (top_edge_hover_timer_.IsRunning() &&
       abs(location_in_screen.x() - mouse_x_when_hit_top_in_screen_) <=
           kMouseRevealXThresholdPixels)
     return;
 
   // Start the reveal if the cursor doesn't move for some amount of time.
   mouse_x_when_hit_top_in_screen_ = location_in_screen.x();
   top_edge_hover_timer_.Stop();
   // Timer is stopped when |this| is destroyed, hence Unretained() is safe.
   top_edge_hover_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kMouseRevealDelayMs),
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kMouseRevealDelayMs),
       base::Bind(
           &ImmersiveFullscreenController::AcquireLocatedEventRevealedLock,
           base::Unretained(this)));
 }
 
 void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock(
     ui::LocatedEvent* event) {
   if (!enabled_)
     return;
   DCHECK(!event || event->IsMouseEvent() || event->IsTouchEvent());
@@ skipping 13 matching lines @@
 
   // Ignore all events while a window has capture. This keeps the top-of-window
   // views revealed during a drag.
   if (aura::client::GetCaptureWindow(native_window_))
     return;
 
   gfx::Point location_in_screen;
   if (event && event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
     location_in_screen = GetEventLocationInScreen(*event);
   } else {
-    aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(
-        native_window_->GetRootWindow());
+    aura::client::CursorClient* cursor_client =
+        aura::client::GetCursorClient(native_window_->GetRootWindow());
     if (!cursor_client->IsMouseEventsEnabled()) {
       // If mouse events are disabled, the user's last interaction was probably
       // via touch. Do no do further processing in this case as there is no easy
       // way of retrieving the position of the user's last touch.
       return;
     }
     location_in_screen = aura::Env::GetInstance()->last_mouse_location();
   }
 
   if ((!event || event->IsMouseEvent()) &&
@@ skipping 39 matching lines @@
 void ImmersiveFullscreenController::UpdateFocusRevealedLock() {
   if (!enabled_)
     return;
 
   bool hold_lock = false;
   if (widget_->IsActive()) {
     views::View* focused_view = widget_->GetFocusManager()->GetFocusedView();
     if (top_container_->Contains(focused_view))
       hold_lock = true;
   } else {
-    aura::Window* active_window = aura::client::GetActivationClient(
-        native_window_->GetRootWindow())->GetActiveWindow();
+    aura::Window* active_window =
+        aura::client::GetActivationClient(native_window_->GetRootWindow())
+            ->GetActiveWindow();
     if (GetAnchorView(active_window)) {
       // BubbleObserver will already have locked the top-of-window views if the
       // bubble is anchored to a child of |top_container_|. Don't acquire
       // |focus_revealed_lock_| here for the sake of simplicity.
       // Note: Instead of checking for the existence of the |anchor_view|,
       // the existence of the |anchor_widget| is performed to avoid the case
       // where the view is already gone (and the widget is still running).
     } else {
       // The currently active window is not |native_window_| and it is not a
       // bubble with an anchor view. The top-of-window views should be revealed
@@ skipping 219 matching lines @@
       ::wm::GetTransientChildren(native_window_);
   for (size_t i = 0; i < transient_children.size(); ++i) {
     aura::Window* transient_child = transient_children[i];
     views::View* anchor_view = GetAnchorView(transient_child);
     if (anchor_view && top_container_->Contains(anchor_view))
       bubble_observer_->StartObserving(transient_child);
   }
 }
 
 }  // namespace ash