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 41 matching lines @@
 
 TabRendererData::NetworkState TabContentsNetworkState(
     WebContents* contents) {
   if (!contents || !contents->IsLoading())
     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->GetInteger(prefs::kTabStripLayoutType) ==
+      TAB_STRIP_LAYOUT_STACKED);

[sky, 2014/05/21 22:57:19]

Seems silly to keep the enum and not use it. I believe Peter was suggesting you
nuke the enum entirely, which I'm ok with. Or at least move it here so that you
document the values that are written to prefs.

[varkha, 2014/05/23 17:43:23]

Right, I left the enum as a way to document the values. I have moved the prefs
values documentation and accessors to tab_strip_layout_type_prefs as it seemed
like a logical place for those.

 }
 
 // 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 294 matching lines @@
   if (match.destination_url.is_valid())
     model_->delegate()->AddTabAt(match.destination_url, -1, true);
 }
 
 bool BrowserTabStripController::IsIncognito() {
   return browser_->profile()->IsOffTheRecord();
 }
 
 void BrowserTabStripController::LayoutTypeMaybeChanged() {
   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 layout_type_stacked =
+      DetermineTabStripLayoutStacked(g_browser_process->local_state(),
+                                     browser_->host_desktop_type(),
+                                     &adjust_layout);
+  if (!adjust_layout || layout_type_stacked == tabstrip_->layout_type_stacked())
     return;
 
   g_browser_process->local_state()->SetInteger(
       prefs::kTabStripLayoutType,
-      static_cast<int>(tabstrip_->layout_type()));
+      static_cast<int>(tabstrip_->layout_type_stacked() ?
+          TAB_STRIP_LAYOUT_STACKED : TAB_STRIP_LAYOUT_SHRINK));
 }
 
 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 149 matching lines @@
   // 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() {
   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 layout_type_stacked =
+      DetermineTabStripLayoutStacked(g_browser_process->local_state(),
+                                     browser_->host_desktop_type(),
+                                     &adjust_layout);
+  tabstrip_->set_adjust_layout(adjust_layout);
+  tabstrip_->SetLayoutTypeStacked(layout_type_stacked);
 }
 
 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));
 }