Changed static variable flag to be a bool in the anon namespace.

ui/app_list/views/app_list_view.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 "ui/app_list/views/app_list_view.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 57 matching lines @@
 // The velocity the app list must be dragged in order to transition to the next
 // state, measured in DIPs/event.
 constexpr int kAppListDragVelocityThreshold = 25;
 
 // The opacity of the app list background.
 constexpr float kAppListOpacity = 0.8;
 
 // The vertical position for the appearing animation of the speech UI.
 constexpr float kSpeechUIAppearingPosition = 12;
 
-bool IsFullscreenAppListEnabled() {
-  // Cache this value to avoid repeated lookup.
-  static bool cached_value = features::IsFullscreenAppListEnabled();
-  return cached_value;
-}
-
 // This view forwards the focus to the search box widget by providing it as a
 // FocusTraversable when a focus search is provided.
 class SearchBoxFocusHost : public views::View {
  public:
   explicit SearchBoxFocusHost(views::Widget* search_box_widget)
       : search_box_widget_(search_box_widget) {}
 
   ~SearchBoxFocusHost() override {}
 
   views::FocusTraversable* GetFocusTraversable() override {
@@ skipping 101 matching lines @@
       app_list_main_view_(nullptr),
       speech_view_(nullptr),
       search_box_focus_host_(nullptr),
       search_box_widget_(nullptr),
       search_box_view_(nullptr),
       app_list_state_(PEEKING),
       display_observer_(this),
       overlay_view_(nullptr),
       animation_observer_(new HideViewAnimationObserver()) {
   CHECK(delegate);
-
+  IsFullscreenAppListEnabled();
   delegate_->GetSpeechUI()->AddObserver(this);
 
-  if (IsFullscreenAppListEnabled())
+  if (is_fullscreen_app_list_enabled_)
     display_observer_.Add(display::Screen::GetScreen());
 }
 
 AppListView::~AppListView() {
   delegate_->GetSpeechUI()->RemoveObserver(this);
   animation_observer_.reset();
   // Remove child views first to ensure no remaining dependencies on delegate_.
   RemoveAllChildViews(true);
 }
 
 void AppListView::Initialize(gfx::NativeView parent, int initial_apps_page) {
   base::Time start_time = base::Time::Now();
+  IsFullscreenAppListEnabled();
   InitContents(parent, initial_apps_page);
   AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
   set_color(kContentsBackgroundColor);
   set_parent_window(parent);
 
-  if (IsFullscreenAppListEnabled())
+  if (is_fullscreen_app_list_enabled_)
     InitializeFullscreen(parent, initial_apps_page);
   else
     InitializeBubble(parent, initial_apps_page);
 
   InitChildWidgets();
   AddChildView(overlay_view_);
 
-  if (IsFullscreenAppListEnabled())
+  if (is_fullscreen_app_list_enabled_)
     SetState(app_list_state_);
 
   if (delegate_)
     delegate_->ViewInitialized();
 
   UMA_HISTOGRAM_TIMES("Apps.AppListCreationTime",
                       base::Time::Now() - start_time);
 }
 
 void AppListView::SetBubbleArrow(views::BubbleBorder::Arrow arrow) {
   GetBubbleFrameView()->bubble_border()->set_arrow(arrow);
   SizeToContents();  // Recalcuates with new border.
   GetBubbleFrameView()->SchedulePaint();
 }
 
 void AppListView::MaybeSetAnchorPoint(const gfx::Point& anchor_point) {
   // if the AppListView is a bubble
-  if (!IsFullscreenAppListEnabled())
+  if (!is_fullscreen_app_list_enabled_)
     SetAnchorRect(gfx::Rect(anchor_point, gfx::Size()));
 }
 
 void AppListView::SetDragAndDropHostOfCurrentAppList(
     ApplicationDragAndDropHost* drag_and_drop_host) {
   app_list_main_view_->SetDragAndDropHostOfCurrentAppList(drag_and_drop_host);
 }
 
 void AppListView::ShowWhenReady() {
   app_list_main_view_->ShowAppListWhenReady();
 }
 
 void AppListView::UpdateBounds() {
   // if the AppListView is a bubble
-  if (!IsFullscreenAppListEnabled())
+  if (!is_fullscreen_app_list_enabled_)
     SizeToContents();
 }
 
 void AppListView::SetAppListOverlayVisible(bool visible) {
   DCHECK(overlay_view_);
 
   // Display the overlay immediately so we can begin the animation.
   overlay_view_->SetVisible(true);
 
   ui::ScopedLayerAnimationSettings settings(
@@ skipping 72 matching lines @@
       ->pagination_model();
 }
 
 void AppListView::InitContents(gfx::NativeView parent, int initial_apps_page) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/440224 and
   // crbug.com/441028 are fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "440224, 441028 AppListView::InitContents"));
 
-  if (IsFullscreenAppListEnabled()) {
+  if (is_fullscreen_app_list_enabled_) {
     // The shield view that colors the background of the app list and makes it
     // transparent.
     app_list_background_shield_ = new views::View;
     app_list_background_shield_->SetPaintToLayer(ui::LAYER_SOLID_COLOR);
     app_list_background_shield_->layer()->SetColor(SK_ColorBLACK);
     app_list_background_shield_->layer()->SetOpacity(kAppListOpacity);
     AddChildView(app_list_background_shield_);
   }
   app_list_main_view_ = new AppListMainView(delegate_, this);
   AddChildView(app_list_main_view_);
@@ skipping 218 matching lines @@
 }
 
 void AppListView::GetWidgetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
   DCHECK(GetBubbleFrameView());
 
   mask->addRect(gfx::RectToSkRect(GetBubbleFrameView()->GetContentsBounds()));
 }
 
 void AppListView::OnMouseEvent(ui::MouseEvent* event) {
-  if (!IsFullscreenAppListEnabled())
+  if (!is_fullscreen_app_list_enabled_)
     return;
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
       StartDrag(event->location());
       event->SetHandled();
       break;
     case ui::ET_MOUSE_DRAGGED:
       UpdateDrag(event->location());
       event->SetHandled();
       break;
     case ui::ET_MOUSE_RELEASED:
       EndDrag(event->location());
       event->SetHandled();
       break;
     default:
       break;
   }
 }
 
 void AppListView::OnGestureEvent(ui::GestureEvent* event) {
-  if (!IsFullscreenAppListEnabled())
+  if (!is_fullscreen_app_list_enabled_)
     return;
 
   switch (event->type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
       StartDrag(event->location());
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE:
       last_fling_velocity_ = event->details().velocity_y();
       UpdateDrag(event->location());
       event->SetHandled();
       break;
     case ui::ET_GESTURE_END:
       EndDrag(event->location());
       event->SetHandled();
       break;
     default:
       break;
   }
 }
 
 bool AppListView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   DCHECK_EQ(ui::VKEY_ESCAPE, accelerator.key_code());
 
   // If the ContentsView does not handle the back action, then this is the
   // top level, so we close the app list.
   if (!app_list_main_view_->contents_view()->Back()) {
-    if (IsFullscreenAppListEnabled()) {
+    if (is_fullscreen_app_list_enabled_) {
       SetState(CLOSED);
     } else {
       app_list_main_view_->Close();
       delegate_->Dismiss();
     }
     GetWidget()->Deactivate();
   }
 
   // Don't let DialogClientView handle the accelerator.
   return true;
@@ skipping 14 matching lines @@
   if (speech_view_) {
     gfx::Rect speech_bounds = centered_bounds;
     int preferred_height = speech_view_->GetPreferredSize().height();
     speech_bounds.Inset(kSpeechUIMargin, kSpeechUIMargin);
     speech_bounds.set_height(
         std::min(speech_bounds.height(), preferred_height));
     speech_bounds.Inset(-speech_view_->GetInsets());
     speech_view_->SetBoundsRect(speech_bounds);
   }
 
-  if (IsFullscreenAppListEnabled()) {
+  if (is_fullscreen_app_list_enabled_) {
     app_list_main_view_->contents_view()->Layout();
     app_list_background_shield_->SetBoundsRect(contents_bounds);
   }
 }
 
 void AppListView::SchedulePaintInRect(const gfx::Rect& rect) {
   BubbleDialogDelegateView::SchedulePaintInRect(rect);
   if (GetBubbleFrameView())
     GetBubbleFrameView()->SchedulePaint();
 }
@@ skipping 16 matching lines @@
       break;
     case CLOSED:
       app_list_main_view_->Close();
       delegate_->Dismiss();
       break;
   }
   fullscreen_widget_->SetBounds(new_widget_bounds);
   app_list_state_ = new_state;
 }
 
+void AppListView::IsFullscreenAppListEnabled() {

[xiyuan, 2017/06/12 22:33:15]

Get rid of this function and just initialize |is_fullscreen_app_list_enabled_|
in ctor.

[newcomer, 2017/06/12 23:48:17]

Done.

+  // Cache this value to avoid repeated lookup.
+  is_fullscreen_app_list_enabled_ = features::IsFullscreenAppListEnabled();
+}
+
 void AppListView::OnWidgetDestroying(views::Widget* widget) {
   BubbleDialogDelegateView::OnWidgetDestroying(widget);
   if (delegate_ && widget == GetWidget())
     delegate_->ViewClosing();
 }
 
 void AppListView::OnWidgetVisibilityChanged(views::Widget* widget,
                                             bool visible) {
   BubbleDialogDelegateView::OnWidgetVisibilityChanged(widget, visible);
 
@@ skipping 66 matching lines @@
     // Refocus the search box. However, if the app list widget does not have
     // focus, it means another window has already taken focus, and we *must not*
     // focus the search box (or we would steal focus back into the app list).
     if (GetWidget()->IsActive())
       search_box_view_->search_box()->RequestFocus();
   }
 }
 
 void AppListView::OnDisplayMetricsChanged(const display::Display& display,
                                           uint32_t changed_metrics) {
-  if (!IsFullscreenAppListEnabled())
+  if (!is_fullscreen_app_list_enabled_)
     return;
 
   // Set the |fullscreen_widget_| size to fit the new display metrics.
   gfx::Size size = display::Screen::GetScreen()
                        ->GetDisplayNearestView(parent_window())
                        .work_area()
                        .size();
   size.Enlarge(0, kShelfSize);
   fullscreen_widget_->SetSize(size);
 
   // Update the |fullscreen_widget_| bounds to accomodate the new work area.
   SetState(app_list_state_);
 }
 
 }  // namespace app_list