Removes --enable-stacked-tab-strip flag (Stacked Tabs)

chrome/browser/ui/views/tabs/browser_tab_strip_controller.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 "chrome/browser/ui/views/tabs/browser_tab_strip_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/task_runner_util.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_renderer_data.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/webplugininfo.h"
 #include "ipc/ipc_message.h"
 #include "net/base/filename_util.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/gfx/image/image.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/widget/widget.h"
 
 using base::UserMetricsAction;
 using content::WebContents;
 
 namespace {
 
 TabRendererData::NetworkState TabContentsNetworkState(
     WebContents* contents) {
   if (!contents || !contents->IsLoadingToDifferentDocument())
     return TabRendererData::NETWORK_STATE_NONE;
   if (contents->IsWaitingForResponse())
     return TabRendererData::NETWORK_STATE_WAITING;
   return TabRendererData::NETWORK_STATE_LOADING;
 }
 
-TabStripLayoutType DetermineTabStripLayout(
+bool DetermineTabStripLayoutStacked(
     PrefService* prefs,
     chrome::HostDesktopType host_desktop_type,
     bool* adjust_layout) {
   *adjust_layout = false;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableStackedTabStrip)) {
-    return TAB_STRIP_LAYOUT_STACKED;
-  }
   // For ash, always allow entering stacked mode.
   if (host_desktop_type != chrome::HOST_DESKTOP_TYPE_ASH)
-    return TAB_STRIP_LAYOUT_SHRINK;
+    return false;
   *adjust_layout = true;
-  switch (prefs->GetInteger(prefs::kTabStripLayoutType)) {
-    case TAB_STRIP_LAYOUT_STACKED:
-      return TAB_STRIP_LAYOUT_STACKED;
-    default:
-      return TAB_STRIP_LAYOUT_SHRINK;
-  }
+  return prefs->GetBoolean(prefs::kTabStripStackedLayout);
 }
 
 // Get the MIME type of the file pointed to by the url, based on the file's
 // extension. Must be called on a thread that allows IO.
 std::string FindURLMimeType(const GURL& url) {
   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   base::FilePath full_path;
   net::FileURLToFilePath(url, &full_path);
 
   // Get the MIME type based on the filename.
@@ skipping 103 matching lines @@
                                                      TabStripModel* model)
     : model_(model),
       tabstrip_(NULL),
       browser_(browser),
       hover_tab_selector_(model),
       weak_ptr_factory_(this) {
   model_->AddObserver(this);
 
   local_pref_registrar_.Init(g_browser_process->local_state());
   local_pref_registrar_.Add(
-      prefs::kTabStripLayoutType,
-      base::Bind(&BrowserTabStripController::UpdateLayoutType,
+      prefs::kTabStripStackedLayout,
+      base::Bind(&BrowserTabStripController::UpdateStackedLayout,
                  base::Unretained(this)));
 }
 
 BrowserTabStripController::~BrowserTabStripController() {
   // When we get here the TabStrip is being deleted. We need to explicitly
   // cancel the menu, otherwise it may try to invoke something on the tabstrip
   // from its destructor.
   if (context_menu_contents_.get())
     context_menu_contents_->Cancel();
 
   model_->RemoveObserver(this);
 }
 
 void BrowserTabStripController::InitFromModel(TabStrip* tabstrip) {
   tabstrip_ = tabstrip;
 
-  UpdateLayoutType();
+  UpdateStackedLayout();
 
   // Walk the model, calling our insertion observer method for each item within
   // it.
   for (int i = 0; i < model_->count(); ++i)
     AddTab(model_->GetWebContentsAt(i), i, model_->active_index() == i);
 }
 
 bool BrowserTabStripController::IsCommandEnabledForTab(
     TabStripModel::ContextMenuCommand command_id,
     Tab* tab) const {
@@ skipping 150 matching lines @@
   AutocompleteClassifierFactory::GetForProfile(profile())->Classify(
       location, false, false, AutocompleteInput::BLANK, &match, NULL);
   if (match.destination_url.is_valid())
     model_->delegate()->AddTabAt(match.destination_url, -1, true);
 }
 
 bool BrowserTabStripController::IsIncognito() {
   return browser_->profile()->IsOffTheRecord();
 }
 
-void BrowserTabStripController::LayoutTypeMaybeChanged() {
+void BrowserTabStripController::StackedLayoutMaybeChanged() {
   bool adjust_layout = false;
-  TabStripLayoutType layout_type =
-      DetermineTabStripLayout(g_browser_process->local_state(),
-                              browser_->host_desktop_type(), &adjust_layout);
-  if (!adjust_layout || layout_type == tabstrip_->layout_type())
+  bool stacked_layout =
+      DetermineTabStripLayoutStacked(g_browser_process->local_state(),
+                                     browser_->host_desktop_type(),
+                                     &adjust_layout);
+  if (!adjust_layout || stacked_layout == tabstrip_->stacked_layout())
     return;
 
-  g_browser_process->local_state()->SetInteger(
-      prefs::kTabStripLayoutType,
-      static_cast<int>(tabstrip_->layout_type()));
+  g_browser_process->local_state()->SetBoolean(prefs::kTabStripStackedLayout,
+                                               tabstrip_->stacked_layout());
 }
 
 void BrowserTabStripController::OnStartedDraggingTabs() {
   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
   if (browser_view && !immersive_reveal_lock_.get()) {
     // The top-of-window views should be revealed while the user is dragging
     // tabs in immersive fullscreen. The top-of-window views may not be already
     // revealed if the user is attempting to attach a tab to a tabstrip
     // belonging to an immersive fullscreen window.
     immersive_reveal_lock_.reset(
@@ skipping 147 matching lines @@
                                        int index,
                                        bool is_active) {
   // Cancel any pending tab transition.
   hover_tab_selector_.CancelTabTransition();
 
   TabRendererData data;
   SetTabRendererDataFromModel(contents, index, &data, NEW_TAB);
   tabstrip_->AddTabAt(index, data, is_active);
 }
 
-void BrowserTabStripController::UpdateLayoutType() {
+void BrowserTabStripController::UpdateStackedLayout() {
   bool adjust_layout = false;
-  TabStripLayoutType layout_type =
-      DetermineTabStripLayout(g_browser_process->local_state(),
-                              browser_->host_desktop_type(), &adjust_layout);
-  tabstrip_->SetLayoutType(layout_type, adjust_layout);
+  bool stacked_layout =
+      DetermineTabStripLayoutStacked(g_browser_process->local_state(),
+                                     browser_->host_desktop_type(),
+                                     &adjust_layout);
+  tabstrip_->set_adjust_layout(adjust_layout);
+  tabstrip_->SetStackedLayout(stacked_layout);
 }
 
 void BrowserTabStripController::OnFindURLMimeTypeCompleted(
     const GURL& url,
     const std::string& mime_type) {
   // Check whether the mime type, if given, is known to be supported or whether
   // there is a plugin that supports the mime type (e.g. PDF).
   // TODO(bauerb): This possibly uses stale information, but it's guaranteed not
   // to do disk access.
   content::WebPluginInfo plugin;
   tabstrip_->FileSupported(
       url,
       mime_type.empty() ||
       net::IsSupportedMimeType(mime_type) ||
       content::PluginService::GetInstance()->GetPluginInfo(
           -1,                // process ID
           MSG_ROUTING_NONE,  // routing ID
           model_->profile()->GetResourceContext(),
           url, GURL(), mime_type, false,
           NULL, &plugin, NULL));
 }