clang-format all of //ash

ash/wm/immersive_fullscreen_controller_unittest.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 "ash/common/shelf/shelf_types.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/mouse_cursor_event_filter.h"
@@ skipping 32 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(TestBubbleDialogDelegate);
 };
 
 class MockImmersiveFullscreenControllerDelegate
     : public ImmersiveFullscreenController::Delegate {
  public:
   MockImmersiveFullscreenControllerDelegate(views::View* top_container_view)
       : top_container_view_(top_container_view),
         enabled_(false),
-        visible_fraction_(1) {
-  }
+        visible_fraction_(1) {}
   ~MockImmersiveFullscreenControllerDelegate() override {}
 
   // ImmersiveFullscreenController::Delegate overrides:
   void OnImmersiveRevealStarted() override {
     enabled_ = true;
     visible_fraction_ = 0;
   }
   void OnImmersiveRevealEnded() override { visible_fraction_ = 0; }
   void OnImmersiveFullscreenExited() override {
     enabled_ = false;
     visible_fraction_ = 1;
   }
   void SetVisibleFraction(double visible_fraction) override {
     visible_fraction_ = visible_fraction;
   }
   std::vector<gfx::Rect> GetVisibleBoundsInScreen() const override {
     std::vector<gfx::Rect> bounds_in_screen;
     bounds_in_screen.push_back(top_container_view_->GetBoundsInScreen());
     return bounds_in_screen;
   }
 
-  bool is_enabled() const {
-    return enabled_;
-  }
+  bool is_enabled() const { return enabled_; }
 
-  double visible_fraction() const {
-    return visible_fraction_;
-  }
+  double visible_fraction() const { return visible_fraction_; }
 
  private:
   views::View* top_container_view_;
   bool enabled_;
   double visible_fraction_;
 
   DISALLOW_COPY_AND_ASSIGN(MockImmersiveFullscreenControllerDelegate);
 };
 
 class ConsumeEventHandler : public ui::test::TestEventHandler {
@@ skipping 20 matching lines @@
   enum Modality {
     MODALITY_MOUSE,
     MODALITY_GESTURE_TAP,
     MODALITY_GESTURE_SCROLL
   };
 
   ImmersiveFullscreenControllerTest()
       : widget_(nullptr), top_container_(nullptr), content_view_(nullptr) {}
   ~ImmersiveFullscreenControllerTest() override {}
 
-  ImmersiveFullscreenController* controller() {
-    return controller_.get();
-  }
+  ImmersiveFullscreenController* controller() { return controller_.get(); }
 
-  views::NativeViewHost* content_view() {
-    return content_view_;
-  }
+  views::NativeViewHost* content_view() { return content_view_; }
 
-  views::View* top_container() {
-    return top_container_;
-  }
+  views::View* top_container() { return top_container_; }
 
   views::Widget* widget() { return widget_; }
 
-  aura::Window* window() {
-    return widget_->GetNativeWindow();
-  }
+  aura::Window* window() { return widget_->GetNativeWindow(); }
 
   MockImmersiveFullscreenControllerDelegate* delegate() {
     return delegate_.get();
   }
 
   // Access to private data from the controller.
   bool top_edge_hover_timer_running() const {
     return controller_->top_edge_hover_timer_.IsRunning();
   }
   int mouse_x_when_hit_top() const {
@@ skipping 12 matching lines @@
 
     window()->SetProperty(aura::client::kShowStateKey,
                           ui::SHOW_STATE_FULLSCREEN);
 
     gfx::Size window_size = widget_->GetWindowBoundsInScreen().size();
     content_view_ = new views::NativeViewHost();
     content_view_->SetBounds(0, 0, window_size.width(), window_size.height());
     widget_->GetContentsView()->AddChildView(content_view_);
 
     top_container_ = new views::View();
-    top_container_->SetBounds(
-        0, 0, window_size.width(), 100);
+    top_container_->SetBounds(0, 0, window_size.width(), 100);
     top_container_->SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
     widget_->GetContentsView()->AddChildView(top_container_);
 
     delegate_.reset(
         new MockImmersiveFullscreenControllerDelegate(top_container_));
     controller_.reset(new ImmersiveFullscreenController);
     controller_->Init(delegate_.get(), widget_, top_container_);
     controller_->SetupForTest();
 
     // The mouse is moved so that it is not over |top_container_| by
@@ skipping 63 matching lines @@
         break;
       }
       case MODALITY_GESTURE_SCROLL: {
         gfx::Point start(0, revealed ? 0 : top_container_->height() - 2);
         gfx::Vector2d scroll_delta(0, 40);
         gfx::Point end = revealed ? start + scroll_delta : start - scroll_delta;
         views::View::ConvertPointToScreen(top_container_, &start);
         views::View::ConvertPointToScreen(top_container_, &end);
         ui::test::EventGenerator& event_generator(GetEventGenerator());
         event_generator.GestureScrollSequence(
-            start, end,
-            base::TimeDelta::FromMilliseconds(30), 1);
+            start, end, base::TimeDelta::FromMilliseconds(30), 1);
         break;
       }
     }
   }
 
   std::unique_ptr<ImmersiveFullscreenController> controller_;
   std::unique_ptr<MockImmersiveFullscreenControllerDelegate> delegate_;
-  views::Widget* widget_;  // Owned by the native widget.
-  views::View* top_container_;  // Owned by |widget_|'s root-view.
+  views::Widget* widget_;                // Owned by the native widget.
+  views::View* top_container_;           // Owned by |widget_|'s root-view.
   views::NativeViewHost* content_view_;  // Owned by |widget_|'s root-view.
 
   DISALLOW_COPY_AND_ASSIGN(ImmersiveFullscreenControllerTest);
 };
 
 // Test the initial state and that the delegate gets notified of the
 // top-of-window views getting hidden and revealed.
 TEST_F(ImmersiveFullscreenControllerTest, Delegate) {
   // Initial state.
   EXPECT_FALSE(controller()->IsEnabled());
@@ skipping 95 matching lines @@
   EXPECT_FALSE(top_edge_hover_timer_running());
 
   // Move to top edge of screen starts hover timer running. We cannot use
   // MoveMouse() because MoveMouse() stops the timer if it started running.
   event_generator.MoveMouseTo(top_edge_pos);
   EXPECT_TRUE(top_edge_hover_timer_running());
   EXPECT_EQ(top_edge_pos.x(), mouse_x_when_hit_top());
 
   // Moving |ImmersiveFullscreenControllerTest::kMouseRevealBoundsHeight| down
   // from the top edge stops it.
-  event_generator.MoveMouseBy(0,
-      ImmersiveFullscreenController::kMouseRevealBoundsHeight);
+  event_generator.MoveMouseBy(
+      0, ImmersiveFullscreenController::kMouseRevealBoundsHeight);
   EXPECT_FALSE(top_edge_hover_timer_running());
 
   // Moving back to the top starts the timer again.
   event_generator.MoveMouseTo(top_edge_pos);
   EXPECT_TRUE(top_edge_hover_timer_running());
   EXPECT_EQ(top_edge_pos.x(), mouse_x_when_hit_top());
 
   // Slight move to the right keeps the timer running for the same hit point.
   event_generator.MoveMouseBy(1, 0);
   EXPECT_TRUE(top_edge_hover_timer_running());
@@ skipping 71 matching lines @@
   gfx::Rect top_container_bounds_in_screen =
       top_container()->GetBoundsInScreen();
   gfx::Rect popup_bounds_in_screen = popup_widget->GetWindowBoundsInScreen();
   ASSERT_EQ(top_container_bounds_in_screen.origin().ToString(),
             popup_bounds_in_screen.origin().ToString());
   ASSERT_GT(top_container_bounds_in_screen.right(),
             popup_bounds_in_screen.right());
 
   // The top-of-window views should stay hidden if the cursor is at the top edge
   // but above an obscured portion of the top-of-window views.
-  MoveMouse(popup_bounds_in_screen.x(),
-            top_container_bounds_in_screen.y());
+  MoveMouse(popup_bounds_in_screen.x(), top_container_bounds_in_screen.y());
   EXPECT_FALSE(controller()->IsRevealed());
 
   // The top-of-window views should reveal if the cursor is at the top edge and
   // above an unobscured portion of the top-of-window views.
   MoveMouse(top_container_bounds_in_screen.right() - 1,
             top_container_bounds_in_screen.y());
   EXPECT_TRUE(controller()->IsRevealed());
 
   // The top-of-window views should stay revealed if the cursor is moved off
   // of the top edge.
@@ skipping 569 matching lines @@
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
 
   // Entering immersive fullscreen keeps auto-hide.
   window()->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   SetEnabled(true);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
 
   // Disabling immersive fullscreen maintains the user's auto-hide selection.
   SetEnabled(false);
-  window()->SetProperty(aura::client::kShowStateKey,
-                        ui::SHOW_STATE_NORMAL);
+  window()->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState());
 }
 
 }  // namespase ash