Home | History | Annotate | Download | only in tabs 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/views/tabs/browser_tab_strip_controller.h"
      6 
      7 #include "base/auto_reset.h"
      8 #include "base/prefs/pref_service.h"
      9 #include "base/task_runner_util.h"
     10 #include "base/threading/sequenced_worker_pool.h"
     11 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
     12 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
     13 #include "chrome/browser/browser_process.h"
     14 #include "chrome/browser/chrome_notification_types.h"
     15 #include "chrome/browser/extensions/tab_helper.h"
     16 #include "chrome/browser/favicon/favicon_tab_helper.h"
     17 #include "chrome/browser/profiles/profile.h"
     18 #include "chrome/browser/search/search.h"
     19 #include "chrome/browser/ui/browser.h"
     20 #include "chrome/browser/ui/browser_tabstrip.h"
     21 #include "chrome/browser/ui/tabs/tab_menu_model.h"
     22 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     23 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
     24 #include "chrome/browser/ui/tabs/tab_utils.h"
     25 #include "chrome/browser/ui/views/frame/browser_view.h"
     26 #include "chrome/browser/ui/views/tabs/tab.h"
     27 #include "chrome/browser/ui/views/tabs/tab_renderer_data.h"
     28 #include "chrome/browser/ui/views/tabs/tab_strip.h"
     29 #include "chrome/common/pref_names.h"
     30 #include "chrome/common/url_constants.h"
     31 #include "components/metrics/proto/omnibox_event.pb.h"
     32 #include "components/omnibox/autocomplete_match.h"
     33 #include "content/public/browser/browser_thread.h"
     34 #include "content/public/browser/notification_service.h"
     35 #include "content/public/browser/plugin_service.h"
     36 #include "content/public/browser/user_metrics.h"
     37 #include "content/public/browser/web_contents.h"
     38 #include "content/public/common/webplugininfo.h"
     39 #include "ipc/ipc_message.h"
     40 #include "net/base/filename_util.h"
     41 #include "ui/base/models/list_selection_model.h"
     42 #include "ui/gfx/image/image.h"
     43 #include "ui/views/controls/menu/menu_runner.h"
     44 #include "ui/views/widget/widget.h"
     45 
     46 using base::UserMetricsAction;
     47 using content::WebContents;
     48 
     49 namespace {
     50 
     51 TabRendererData::NetworkState TabContentsNetworkState(
     52     WebContents* contents) {
     53   if (!contents || !contents->IsLoadingToDifferentDocument())
     54     return TabRendererData::NETWORK_STATE_NONE;
     55   if (contents->IsWaitingForResponse())
     56     return TabRendererData::NETWORK_STATE_WAITING;
     57   return TabRendererData::NETWORK_STATE_LOADING;
     58 }
     59 
     60 bool DetermineTabStripLayoutStacked(
     61     PrefService* prefs,
     62     chrome::HostDesktopType host_desktop_type,
     63     bool* adjust_layout) {
     64   *adjust_layout = false;
     65   // For ash, always allow entering stacked mode.
     66   if (host_desktop_type != chrome::HOST_DESKTOP_TYPE_ASH)
     67     return false;
     68   *adjust_layout = true;
     69   return prefs->GetBoolean(prefs::kTabStripStackedLayout);
     70 }
     71 
     72 // Get the MIME type of the file pointed to by the url, based on the file's
     73 // extension. Must be called on a thread that allows IO.
     74 std::string FindURLMimeType(const GURL& url) {
     75   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     76   base::FilePath full_path;
     77   net::FileURLToFilePath(url, &full_path);
     78 
     79   // Get the MIME type based on the filename.
     80   std::string mime_type;
     81   net::GetMimeTypeFromFile(full_path, &mime_type);
     82 
     83   return mime_type;
     84 }
     85 
     86 }  // namespace
     87 
     88 class BrowserTabStripController::TabContextMenuContents
     89     : public ui::SimpleMenuModel::Delegate {
     90  public:
     91   TabContextMenuContents(Tab* tab,
     92                          BrowserTabStripController* controller)
     93       : tab_(tab),
     94         controller_(controller),
     95         last_command_(TabStripModel::CommandFirst) {
     96     model_.reset(new TabMenuModel(
     97         this, controller->model_,
     98         controller->tabstrip_->GetModelIndexOfTab(tab)));
     99     menu_runner_.reset(new views::MenuRunner(
    100         model_.get(),
    101         views::MenuRunner::HAS_MNEMONICS | views::MenuRunner::CONTEXT_MENU));
    102   }
    103 
    104   virtual ~TabContextMenuContents() {
    105     if (controller_)
    106       controller_->tabstrip_->StopAllHighlighting();
    107   }
    108 
    109   void Cancel() {
    110     controller_ = NULL;
    111   }
    112 
    113   void RunMenuAt(const gfx::Point& point, ui::MenuSourceType source_type) {
    114     if (menu_runner_->RunMenuAt(tab_->GetWidget(),
    115                                 NULL,
    116                                 gfx::Rect(point, gfx::Size()),
    117                                 views::MENU_ANCHOR_TOPLEFT,
    118                                 source_type) ==
    119         views::MenuRunner::MENU_DELETED) {
    120       return;
    121     }
    122   }
    123 
    124   // Overridden from ui::SimpleMenuModel::Delegate:
    125   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE {
    126     return false;
    127   }
    128   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE {
    129     return controller_->IsCommandEnabledForTab(
    130         static_cast<TabStripModel::ContextMenuCommand>(command_id),
    131         tab_);
    132   }
    133   virtual bool GetAcceleratorForCommandId(
    134       int command_id,
    135       ui::Accelerator* accelerator) OVERRIDE {
    136     int browser_cmd;
    137     return TabStripModel::ContextMenuCommandToBrowserCommand(command_id,
    138                                                              &browser_cmd) ?
    139         controller_->tabstrip_->GetWidget()->GetAccelerator(browser_cmd,
    140                                                             accelerator) :
    141         false;
    142   }
    143   virtual void CommandIdHighlighted(int command_id) OVERRIDE {
    144     controller_->StopHighlightTabsForCommand(last_command_, tab_);
    145     last_command_ = static_cast<TabStripModel::ContextMenuCommand>(command_id);
    146     controller_->StartHighlightTabsForCommand(last_command_, tab_);
    147   }
    148   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE {
    149     // Executing the command destroys |this|, and can also end up destroying
    150     // |controller_|. So stop the highlights before executing the command.
    151     controller_->tabstrip_->StopAllHighlighting();
    152     controller_->ExecuteCommandForTab(
    153         static_cast<TabStripModel::ContextMenuCommand>(command_id),
    154         tab_);
    155   }
    156 
    157   virtual void MenuClosed(ui::SimpleMenuModel* /*source*/) OVERRIDE {
    158     if (controller_)
    159       controller_->tabstrip_->StopAllHighlighting();
    160   }
    161 
    162  private:
    163   scoped_ptr<TabMenuModel> model_;
    164   scoped_ptr<views::MenuRunner> menu_runner_;
    165 
    166   // The tab we're showing a menu for.
    167   Tab* tab_;
    168 
    169   // A pointer back to our hosting controller, for command state information.
    170   BrowserTabStripController* controller_;
    171 
    172   // The last command that was selected, so that we can start/stop highlighting
    173   // appropriately as the user moves through the menu.
    174   TabStripModel::ContextMenuCommand last_command_;
    175 
    176   DISALLOW_COPY_AND_ASSIGN(TabContextMenuContents);
    177 };
    178 
    179 ////////////////////////////////////////////////////////////////////////////////
    180 // BrowserTabStripController, public:
    181 
    182 BrowserTabStripController::BrowserTabStripController(Browser* browser,
    183                                                      TabStripModel* model)
    184     : model_(model),
    185       tabstrip_(NULL),
    186       browser_(browser),
    187       hover_tab_selector_(model),
    188       weak_ptr_factory_(this) {
    189   model_->AddObserver(this);
    190 
    191   local_pref_registrar_.Init(g_browser_process->local_state());
    192   local_pref_registrar_.Add(
    193       prefs::kTabStripStackedLayout,
    194       base::Bind(&BrowserTabStripController::UpdateStackedLayout,
    195                  base::Unretained(this)));
    196 }
    197 
    198 BrowserTabStripController::~BrowserTabStripController() {
    199   // When we get here the TabStrip is being deleted. We need to explicitly
    200   // cancel the menu, otherwise it may try to invoke something on the tabstrip
    201   // from its destructor.
    202   if (context_menu_contents_.get())
    203     context_menu_contents_->Cancel();
    204 
    205   model_->RemoveObserver(this);
    206 }
    207 
    208 void BrowserTabStripController::InitFromModel(TabStrip* tabstrip) {
    209   tabstrip_ = tabstrip;
    210 
    211   UpdateStackedLayout();
    212 
    213   // Walk the model, calling our insertion observer method for each item within
    214   // it.
    215   for (int i = 0; i < model_->count(); ++i)
    216     AddTab(model_->GetWebContentsAt(i), i, model_->active_index() == i);
    217 }
    218 
    219 bool BrowserTabStripController::IsCommandEnabledForTab(
    220     TabStripModel::ContextMenuCommand command_id,
    221     Tab* tab) const {
    222   int model_index = tabstrip_->GetModelIndexOfTab(tab);
    223   return model_->ContainsIndex(model_index) ?
    224       model_->IsContextMenuCommandEnabled(model_index, command_id) : false;
    225 }
    226 
    227 void BrowserTabStripController::ExecuteCommandForTab(
    228     TabStripModel::ContextMenuCommand command_id,
    229     Tab* tab) {
    230   int model_index = tabstrip_->GetModelIndexOfTab(tab);
    231   if (model_->ContainsIndex(model_index))
    232     model_->ExecuteContextMenuCommand(model_index, command_id);
    233 }
    234 
    235 bool BrowserTabStripController::IsTabPinned(Tab* tab) const {
    236   return IsTabPinned(tabstrip_->GetModelIndexOfTab(tab));
    237 }
    238 
    239 const ui::ListSelectionModel& BrowserTabStripController::GetSelectionModel() {
    240   return model_->selection_model();
    241 }
    242 
    243 int BrowserTabStripController::GetCount() const {
    244   return model_->count();
    245 }
    246 
    247 bool BrowserTabStripController::IsValidIndex(int index) const {
    248   return model_->ContainsIndex(index);
    249 }
    250 
    251 bool BrowserTabStripController::IsActiveTab(int model_index) const {
    252   return model_->active_index() == model_index;
    253 }
    254 
    255 int BrowserTabStripController::GetActiveIndex() const {
    256   return model_->active_index();
    257 }
    258 
    259 bool BrowserTabStripController::IsTabSelected(int model_index) const {
    260   return model_->IsTabSelected(model_index);
    261 }
    262 
    263 bool BrowserTabStripController::IsTabPinned(int model_index) const {
    264   return model_->ContainsIndex(model_index) && model_->IsTabPinned(model_index);
    265 }
    266 
    267 bool BrowserTabStripController::IsNewTabPage(int model_index) const {
    268   if (!model_->ContainsIndex(model_index))
    269     return false;
    270 
    271   const WebContents* contents = model_->GetWebContentsAt(model_index);
    272   return contents && (contents->GetURL() == GURL(chrome::kChromeUINewTabURL) ||
    273       chrome::IsInstantNTP(contents));
    274 }
    275 
    276 void BrowserTabStripController::SelectTab(int model_index) {
    277   model_->ActivateTabAt(model_index, true);
    278 }
    279 
    280 void BrowserTabStripController::ExtendSelectionTo(int model_index) {
    281   model_->ExtendSelectionTo(model_index);
    282 }
    283 
    284 void BrowserTabStripController::ToggleSelected(int model_index) {
    285   model_->ToggleSelectionAt(model_index);
    286 }
    287 
    288 void BrowserTabStripController::AddSelectionFromAnchorTo(int model_index) {
    289   model_->AddSelectionFromAnchorTo(model_index);
    290 }
    291 
    292 void BrowserTabStripController::CloseTab(int model_index,
    293                                          CloseTabSource source) {
    294   // Cancel any pending tab transition.
    295   hover_tab_selector_.CancelTabTransition();
    296 
    297   tabstrip_->PrepareForCloseAt(model_index, source);
    298   model_->CloseWebContentsAt(model_index,
    299                              TabStripModel::CLOSE_USER_GESTURE |
    300                              TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
    301 }
    302 
    303 void BrowserTabStripController::ToggleTabAudioMute(int model_index) {
    304   content::WebContents* const contents = model_->GetWebContentsAt(model_index);
    305   chrome::SetTabAudioMuted(contents, !chrome::IsTabAudioMuted(contents));
    306 }
    307 
    308 void BrowserTabStripController::ShowContextMenuForTab(
    309     Tab* tab,
    310     const gfx::Point& p,
    311     ui::MenuSourceType source_type) {
    312   context_menu_contents_.reset(new TabContextMenuContents(tab, this));
    313   context_menu_contents_->RunMenuAt(p, source_type);
    314 }
    315 
    316 void BrowserTabStripController::UpdateLoadingAnimations() {
    317   // Don't use the model count here as it's possible for this to be invoked
    318   // before we've applied an update from the model (Browser::TabInsertedAt may
    319   // be processed before us and invokes this).
    320   for (int i = 0, tab_count = tabstrip_->tab_count(); i < tab_count; ++i) {
    321     if (model_->ContainsIndex(i)) {
    322       Tab* tab = tabstrip_->tab_at(i);
    323       WebContents* contents = model_->GetWebContentsAt(i);
    324       tab->UpdateLoadingAnimation(TabContentsNetworkState(contents));
    325     }
    326   }
    327 }
    328 
    329 int BrowserTabStripController::HasAvailableDragActions() const {
    330   return model_->delegate()->GetDragActions();
    331 }
    332 
    333 void BrowserTabStripController::OnDropIndexUpdate(int index,
    334                                                   bool drop_before) {
    335   // Perform a delayed tab transition if hovering directly over a tab.
    336   // Otherwise, cancel the pending one.
    337   if (index != -1 && !drop_before) {
    338     hover_tab_selector_.StartTabTransition(index);
    339   } else {
    340     hover_tab_selector_.CancelTabTransition();
    341   }
    342 }
    343 
    344 void BrowserTabStripController::PerformDrop(bool drop_before,
    345                                             int index,
    346                                             const GURL& url) {
    347   chrome::NavigateParams params(browser_, url, ui::PAGE_TRANSITION_LINK);
    348   params.tabstrip_index = index;
    349 
    350   if (drop_before) {
    351     content::RecordAction(UserMetricsAction("Tab_DropURLBetweenTabs"));
    352     params.disposition = NEW_FOREGROUND_TAB;
    353   } else {
    354     content::RecordAction(UserMetricsAction("Tab_DropURLOnTab"));
    355     params.disposition = CURRENT_TAB;
    356     params.source_contents = model_->GetWebContentsAt(index);
    357   }
    358   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
    359   chrome::Navigate(&params);
    360 }
    361 
    362 bool BrowserTabStripController::IsCompatibleWith(TabStrip* other) const {
    363   Profile* other_profile =
    364       static_cast<BrowserTabStripController*>(other->controller())->profile();
    365   return other_profile == profile();
    366 }
    367 
    368 void BrowserTabStripController::CreateNewTab() {
    369   model_->delegate()->AddTabAt(GURL(), -1, true);
    370 }
    371 
    372 void BrowserTabStripController::CreateNewTabWithLocation(
    373     const base::string16& location) {
    374   // Use autocomplete to clean up the text, going so far as to turn it into
    375   // a search query if necessary.
    376   AutocompleteMatch match;
    377   AutocompleteClassifierFactory::GetForProfile(profile())->Classify(
    378       location, false, false, metrics::OmniboxEventProto::BLANK, &match, NULL);
    379   if (match.destination_url.is_valid())
    380     model_->delegate()->AddTabAt(match.destination_url, -1, true);
    381 }
    382 
    383 bool BrowserTabStripController::IsIncognito() {
    384   return browser_->profile()->IsOffTheRecord();
    385 }
    386 
    387 void BrowserTabStripController::StackedLayoutMaybeChanged() {
    388   bool adjust_layout = false;
    389   bool stacked_layout =
    390       DetermineTabStripLayoutStacked(g_browser_process->local_state(),
    391                                      browser_->host_desktop_type(),
    392                                      &adjust_layout);
    393   if (!adjust_layout || stacked_layout == tabstrip_->stacked_layout())
    394     return;
    395 
    396   g_browser_process->local_state()->SetBoolean(prefs::kTabStripStackedLayout,
    397                                                tabstrip_->stacked_layout());
    398 }
    399 
    400 void BrowserTabStripController::OnStartedDraggingTabs() {
    401   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
    402   if (browser_view && !immersive_reveal_lock_.get()) {
    403     // The top-of-window views should be revealed while the user is dragging
    404     // tabs in immersive fullscreen. The top-of-window views may not be already
    405     // revealed if the user is attempting to attach a tab to a tabstrip
    406     // belonging to an immersive fullscreen window.
    407     immersive_reveal_lock_.reset(
    408         browser_view->immersive_mode_controller()->GetRevealedLock(
    409             ImmersiveModeController::ANIMATE_REVEAL_NO));
    410   }
    411 }
    412 
    413 void BrowserTabStripController::OnStoppedDraggingTabs() {
    414   immersive_reveal_lock_.reset();
    415 }
    416 
    417 void BrowserTabStripController::CheckFileSupported(const GURL& url) {
    418   base::PostTaskAndReplyWithResult(
    419       content::BrowserThread::GetBlockingPool(),
    420       FROM_HERE,
    421       base::Bind(&FindURLMimeType, url),
    422       base::Bind(&BrowserTabStripController::OnFindURLMimeTypeCompleted,
    423                  weak_ptr_factory_.GetWeakPtr(),
    424                  url));
    425 }
    426 
    427 ////////////////////////////////////////////////////////////////////////////////
    428 // BrowserTabStripController, TabStripModelObserver implementation:
    429 
    430 void BrowserTabStripController::TabInsertedAt(WebContents* contents,
    431                                               int model_index,
    432                                               bool is_active) {
    433   DCHECK(contents);
    434   DCHECK(model_->ContainsIndex(model_index));
    435   AddTab(contents, model_index, is_active);
    436 }
    437 
    438 void BrowserTabStripController::TabDetachedAt(WebContents* contents,
    439                                               int model_index) {
    440   // Cancel any pending tab transition.
    441   hover_tab_selector_.CancelTabTransition();
    442 
    443   tabstrip_->RemoveTabAt(model_index);
    444 }
    445 
    446 void BrowserTabStripController::TabSelectionChanged(
    447     TabStripModel* tab_strip_model,
    448     const ui::ListSelectionModel& old_model) {
    449   tabstrip_->SetSelection(old_model, model_->selection_model());
    450 }
    451 
    452 void BrowserTabStripController::TabMoved(WebContents* contents,
    453                                          int from_model_index,
    454                                          int to_model_index) {
    455   // Cancel any pending tab transition.
    456   hover_tab_selector_.CancelTabTransition();
    457 
    458   // Pass in the TabRendererData as the pinned state may have changed.
    459   TabRendererData data;
    460   SetTabRendererDataFromModel(contents, to_model_index, &data, EXISTING_TAB);
    461   tabstrip_->MoveTab(from_model_index, to_model_index, data);
    462 }
    463 
    464 void BrowserTabStripController::TabChangedAt(WebContents* contents,
    465                                              int model_index,
    466                                              TabChangeType change_type) {
    467   if (change_type == TITLE_NOT_LOADING) {
    468     tabstrip_->TabTitleChangedNotLoading(model_index);
    469     // We'll receive another notification of the change asynchronously.
    470     return;
    471   }
    472 
    473   SetTabDataAt(contents, model_index);
    474 }
    475 
    476 void BrowserTabStripController::TabReplacedAt(TabStripModel* tab_strip_model,
    477                                               WebContents* old_contents,
    478                                               WebContents* new_contents,
    479                                               int model_index) {
    480   SetTabDataAt(new_contents, model_index);
    481 }
    482 
    483 void BrowserTabStripController::TabPinnedStateChanged(WebContents* contents,
    484                                                       int model_index) {
    485   // Currently none of the renderers render pinned state differently.
    486 }
    487 
    488 void BrowserTabStripController::TabMiniStateChanged(WebContents* contents,
    489                                                     int model_index) {
    490   SetTabDataAt(contents, model_index);
    491 }
    492 
    493 void BrowserTabStripController::TabBlockedStateChanged(WebContents* contents,
    494                                                        int model_index) {
    495   SetTabDataAt(contents, model_index);
    496 }
    497 
    498 void BrowserTabStripController::SetTabRendererDataFromModel(
    499     WebContents* contents,
    500     int model_index,
    501     TabRendererData* data,
    502     TabStatus tab_status) {
    503   FaviconTabHelper* favicon_tab_helper =
    504       FaviconTabHelper::FromWebContents(contents);
    505 
    506   data->favicon = favicon_tab_helper->GetFavicon().AsImageSkia();
    507   data->network_state = TabContentsNetworkState(contents);
    508   data->title = contents->GetTitle();
    509   data->url = contents->GetURL();
    510   data->loading = contents->IsLoading();
    511   data->crashed_status = contents->GetCrashedStatus();
    512   data->incognito = contents->GetBrowserContext()->IsOffTheRecord();
    513   data->mini = model_->IsMiniTab(model_index);
    514   data->show_icon = data->mini || favicon_tab_helper->ShouldDisplayFavicon();
    515   data->blocked = model_->IsTabBlocked(model_index);
    516   data->app = extensions::TabHelper::FromWebContents(contents)->is_app();
    517   data->media_state = chrome::GetTabMediaStateForContents(contents);
    518 }
    519 
    520 void BrowserTabStripController::SetTabDataAt(content::WebContents* web_contents,
    521                                              int model_index) {
    522   TabRendererData data;
    523   SetTabRendererDataFromModel(web_contents, model_index, &data, EXISTING_TAB);
    524   tabstrip_->SetTabData(model_index, data);
    525 }
    526 
    527 void BrowserTabStripController::StartHighlightTabsForCommand(
    528     TabStripModel::ContextMenuCommand command_id,
    529     Tab* tab) {
    530   if (command_id == TabStripModel::CommandCloseOtherTabs ||
    531       command_id == TabStripModel::CommandCloseTabsToRight) {
    532     int model_index = tabstrip_->GetModelIndexOfTab(tab);
    533     if (IsValidIndex(model_index)) {
    534       std::vector<int> indices =
    535           model_->GetIndicesClosedByCommand(model_index, command_id);
    536       for (std::vector<int>::const_iterator i(indices.begin());
    537            i != indices.end(); ++i) {
    538         tabstrip_->StartHighlight(*i);
    539       }
    540     }
    541   }
    542 }
    543 
    544 void BrowserTabStripController::StopHighlightTabsForCommand(
    545     TabStripModel::ContextMenuCommand command_id,
    546     Tab* tab) {
    547   if (command_id == TabStripModel::CommandCloseTabsToRight ||
    548       command_id == TabStripModel::CommandCloseOtherTabs) {
    549     // Just tell all Tabs to stop pulsing - it's safe.
    550     tabstrip_->StopAllHighlighting();
    551   }
    552 }
    553 
    554 void BrowserTabStripController::AddTab(WebContents* contents,
    555                                        int index,
    556                                        bool is_active) {
    557   // Cancel any pending tab transition.
    558   hover_tab_selector_.CancelTabTransition();
    559 
    560   TabRendererData data;
    561   SetTabRendererDataFromModel(contents, index, &data, NEW_TAB);
    562   tabstrip_->AddTabAt(index, data, is_active);
    563 }
    564 
    565 void BrowserTabStripController::UpdateStackedLayout() {
    566   bool adjust_layout = false;
    567   bool stacked_layout =
    568       DetermineTabStripLayoutStacked(g_browser_process->local_state(),
    569                                      browser_->host_desktop_type(),
    570                                      &adjust_layout);
    571   tabstrip_->set_adjust_layout(adjust_layout);
    572   tabstrip_->SetStackedLayout(stacked_layout);
    573 }
    574 
    575 void BrowserTabStripController::OnFindURLMimeTypeCompleted(
    576     const GURL& url,
    577     const std::string& mime_type) {
    578   // Check whether the mime type, if given, is known to be supported or whether
    579   // there is a plugin that supports the mime type (e.g. PDF).
    580   // TODO(bauerb): This possibly uses stale information, but it's guaranteed not
    581   // to do disk access.
    582   content::WebPluginInfo plugin;
    583   tabstrip_->FileSupported(
    584       url,
    585       mime_type.empty() ||
    586       net::IsSupportedMimeType(mime_type) ||
    587       content::PluginService::GetInstance()->GetPluginInfo(
    588           -1,                // process ID
    589           MSG_ROUTING_NONE,  // routing ID
    590           model_->profile()->GetResourceContext(),
    591           url, GURL(), mime_type, false,
    592           NULL, &plugin, NULL));
    593 }
    594