clang-format all of //ash

ash/frame/custom_frame_view_ash.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/frame/custom_frame_view_ash.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/aura/wm_window_aura.h"
@@ skipping 56 matching lines @@
     window_state_ = window_state;
     window_state_->AddObserver(this);
     GetAuraWindow()->AddObserver(this);
   }
   ~CustomFrameViewAshWindowStateDelegate() override {
     if (window_state_) {
       window_state_->RemoveObserver(this);
       GetAuraWindow()->RemoveObserver(this);
     }
   }
+
  private:
   aura::Window* GetAuraWindow() {
     return ash::WmWindowAura::GetAuraWindow(window_state_->window());
   }
 
   // Overridden from ash::wm::WindowStateDelegate:
   bool ToggleFullscreen(ash::wm::WindowState* window_state) override {
     bool enter_fullscreen = !window_state->IsFullscreen();
     if (enter_fullscreen) {
       GetAuraWindow()->SetProperty(aura::client::kShowStateKey,
@@ skipping 10 matching lines @@
   }
   // Overridden from aura::WindowObserver:
   void OnWindowDestroying(aura::Window* window) override {
     window_state_->RemoveObserver(this);
     GetAuraWindow()->RemoveObserver(this);
     window_state_ = NULL;
   }
   // Overridden from ash::wm::WindowStateObserver:
   void OnPostWindowStateTypeChange(ash::wm::WindowState* window_state,
                                    ash::wm::WindowStateType old_type) override {
-    if (!window_state->IsFullscreen() &&
-        !window_state->IsMinimized() &&
+    if (!window_state->IsFullscreen() && !window_state->IsMinimized() &&
         immersive_fullscreen_controller_.get() &&
         immersive_fullscreen_controller_->IsEnabled()) {
       immersive_fullscreen_controller_->SetEnabled(
-          ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER,
-          false);
+          ash::ImmersiveFullscreenController::WINDOW_TYPE_OTHER, false);
     }
   }
 
   ash::wm::WindowState* window_state_;
   std::unique_ptr<ash::ImmersiveFullscreenController>
       immersive_fullscreen_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomFrameViewAshWindowStateDelegate);
 };
 
@@ skipping 42 matching lines @@
   void ChildPreferredSizeChanged(views::View* child) override;
 
   // ShellObserver:
   void OnMaximizeModeStarted() override;
   void OnMaximizeModeEnded() override;
 
   FrameCaptionButtonContainerView* caption_button_container() {
     return caption_button_container_;
   }
 
-  views::View* avatar_icon() const {
-    return avatar_icon_;
-  }
+  views::View* avatar_icon() const { return avatar_icon_; }
 
  private:
   // ImmersiveFullscreenController::Delegate:
   void OnImmersiveRevealStarted() override;
   void OnImmersiveRevealEnded() override;
   void OnImmersiveFullscreenExited() override;
   void SetVisibleFraction(double visible_fraction) override;
   std::vector<gfx::Rect> GetVisibleBoundsInScreen() const override;
 
   // The widget that the caption buttons act on.
@@ skipping 37 matching lines @@
 void CustomFrameViewAsh::HeaderView::SchedulePaintForTitle() {
   header_painter_->SchedulePaintForTitle();
 }
 
 void CustomFrameViewAsh::HeaderView::ResetWindowControls() {
   caption_button_container_->ResetWindowControls();
 }
 
 int CustomFrameViewAsh::HeaderView::GetPreferredOnScreenHeight() const {
   if (frame_->IsFullscreen()) {
-    return static_cast<int>(
-        GetPreferredHeight() * fullscreen_visible_fraction_);
+    return static_cast<int>(GetPreferredHeight() *
+                            fullscreen_visible_fraction_);
   }
   return GetPreferredHeight();
 }
 
 int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
   return header_painter_->GetHeaderHeightForPainting();
 }
 
 int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
   return header_painter_->GetMinimumHeaderWidth();
@@ skipping 21 matching lines @@
   Layout();
 }
 
 void CustomFrameViewAsh::HeaderView::SizeConstraintsChanged() {
   caption_button_container_->ResetWindowControls();
   caption_button_container_->UpdateSizeButtonVisibility();
   Layout();
 }
 
 void CustomFrameViewAsh::HeaderView::SetFrameColors(
-    SkColor active_frame_color, SkColor inactive_frame_color) {
+    SkColor active_frame_color,
+    SkColor inactive_frame_color) {
   header_painter_->SetFrameColors(active_frame_color, inactive_frame_color);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh::HeaderView, views::View overrides:
 
 void CustomFrameViewAsh::HeaderView::Layout() {
   header_painter_->LayoutHeader();
 }
 
 void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
   bool paint_as_active =
       frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
   caption_button_container_->SetPaintAsActive(paint_as_active);
 
-  HeaderPainter::Mode header_mode = paint_as_active ?
-      HeaderPainter::MODE_ACTIVE : HeaderPainter::MODE_INACTIVE;
+  HeaderPainter::Mode header_mode = paint_as_active
+                                        ? HeaderPainter::MODE_ACTIVE
+                                        : HeaderPainter::MODE_INACTIVE;
   header_painter_->PaintHeader(canvas, header_mode);
 }
 
-void CustomFrameViewAsh::HeaderView::
-    ChildPreferredSizeChanged(views::View* child) {
+void CustomFrameViewAsh::HeaderView::ChildPreferredSizeChanged(
+    views::View* child) {
   // FrameCaptionButtonContainerView animates the visibility changes in
   // UpdateSizeButtonVisibility(false). Due to this a new size is not available
   // until the completion of the animation. Layout in response to the preferred
   // size changes.
   if (child != caption_button_container_)
     return;
   parent()->Layout();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 77 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(OverlayView);
 };
 
 CustomFrameViewAsh::OverlayView::OverlayView(HeaderView* header_view)
     : header_view_(header_view) {
   AddChildView(header_view);
   SetEventTargeter(
       std::unique_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
 }
 
-CustomFrameViewAsh::OverlayView::~OverlayView() {
-}
+CustomFrameViewAsh::OverlayView::~OverlayView() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh::OverlayView, views::View overrides:
 
 void CustomFrameViewAsh::OverlayView::Layout() {
   // Layout |header_view_| because layout affects the result of
   // GetPreferredOnScreenHeight().
   header_view_->Layout();
 
   int onscreen_height = header_view_->GetPreferredOnScreenHeight();
@@ skipping 35 matching lines @@
 
   // A delegate for a more complex way of fullscreening the window may already
   // be set. This is the case for packaged apps.
   wm::WindowState* window_state = wm::GetWindowState(frame->GetNativeWindow());
   if (!window_state->HasDelegate()) {
     window_state->SetDelegate(std::unique_ptr<wm::WindowStateDelegate>(
         new CustomFrameViewAshWindowStateDelegate(window_state, this)));
   }
 }
 
-CustomFrameViewAsh::~CustomFrameViewAsh() {
-}
+CustomFrameViewAsh::~CustomFrameViewAsh() {}
 
 void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
     ImmersiveFullscreenController* immersive_fullscreen_controller) {
   immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
 }
 
 void CustomFrameViewAsh::SetFrameColors(SkColor active_frame_color,
                                         SkColor inactive_frame_color) {
   header_view_->SetFrameColors(active_frame_color, inactive_frame_color);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh, views::NonClientFrameView overrides:
 
 gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
   gfx::Rect client_bounds = bounds();
   client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
   return client_bounds;
 }
 
 gfx::Rect CustomFrameViewAsh::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
   gfx::Rect window_bounds = client_bounds;
   window_bounds.Inset(0, -NonClientTopBorderHeight(), 0, 0);
   return window_bounds;
 }
 
 int CustomFrameViewAsh::NonClientHitTest(const gfx::Point& point) {
-  return FrameBorderHitTestController::NonClientHitTest(this,
-      header_view_->caption_button_container(), point);
+  return FrameBorderHitTestController::NonClientHitTest(
+      this, header_view_->caption_button_container(), point);
 }
 
 void CustomFrameViewAsh::GetWindowMask(const gfx::Size& size,
                                        gfx::Path* window_mask) {
   // No window masks in Aura.
 }
 
 void CustomFrameViewAsh::ResetWindowControls() {
   header_view_->ResetWindowControls();
 }
 
-void CustomFrameViewAsh::UpdateWindowIcon() {
-}
+void CustomFrameViewAsh::UpdateWindowIcon() {}
 
 void CustomFrameViewAsh::UpdateWindowTitle() {
   header_view_->SchedulePaintForTitle();
 }
 
 void CustomFrameViewAsh::SizeConstraintsChanged() {
   header_view_->SizeConstraintsChanged();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh, views::View overrides:
 
 gfx::Size CustomFrameViewAsh::GetPreferredSize() const {
   gfx::Size pref = frame_->client_view()->GetPreferredSize();
   gfx::Rect bounds(0, 0, pref.width(), pref.height());
-  return frame_->non_client_view()->GetWindowBoundsForClientBounds(
-      bounds).size();
+  return frame_->non_client_view()
+      ->GetWindowBoundsForClientBounds(bounds)
+      .size();
 }
 
 void CustomFrameViewAsh::Layout() {
   views::NonClientFrameView::Layout();
   frame_->GetNativeWindow()->SetProperty(aura::client::kTopViewInset,
                                          NonClientTopBorderHeight());
 }
 
 const char* CustomFrameViewAsh::GetClassName() const {
   return kViewClassName;
@@ skipping 54 matching lines @@
 
 // views::NonClientFrameView:
 bool CustomFrameViewAsh::DoesIntersectRect(const views::View* target,
                                            const gfx::Rect& rect) const {
   CHECK_EQ(target, this);
   // NonClientView hit tests the NonClientFrameView first instead of going in
   // z-order. Return false so that events get to the OverlayView.
   return false;
 }
 
-FrameCaptionButtonContainerView* CustomFrameViewAsh::
-    GetFrameCaptionButtonContainerViewForTest() {
+FrameCaptionButtonContainerView*
+CustomFrameViewAsh::GetFrameCaptionButtonContainerViewForTest() {
   return header_view_->caption_button_container();
 }
 
 int CustomFrameViewAsh::NonClientTopBorderHeight() const {
   return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
 }
 
 }  // namespace ash