Remove HostDesktopType from sessions and tab restore

components/sessions/core/tab_restore_service_helper.cc

 // Copyright 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 "components/sessions/core/tab_restore_service_helper.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 117 matching lines @@
     observer_->OnClearEntries();
   STLDeleteElements(&entries_);
   NotifyTabsChanged();
 }
 
 const TabRestoreService::Entries& TabRestoreServiceHelper::entries() const {
   return entries_;
 }
 
 std::vector<LiveTab*> TabRestoreServiceHelper::RestoreMostRecentEntry(
-    LiveTabContext* context,
-    int host_desktop_type) {
+    LiveTabContext* context) {
   if (entries_.empty())
     return std::vector<LiveTab*>();
 
-  return RestoreEntryById(context, entries_.front()->id, host_desktop_type,
-                          UNKNOWN);
+  return RestoreEntryById(context, entries_.front()->id, UNKNOWN);
 }
 
 TabRestoreService::Tab* TabRestoreServiceHelper::RemoveTabEntryById(
     SessionID::id_type id) {
   Entries::iterator i = GetEntryIteratorById(id);
   if (i == entries_.end())
     return NULL;
 
   Entry* entry = *i;
   if (entry->type != TabRestoreService::TAB)
     return NULL;
 
   Tab* tab = static_cast<Tab*>(entry);
   entries_.erase(i);
   return tab;
 }
 
 std::vector<LiveTab*> TabRestoreServiceHelper::RestoreEntryById(
     LiveTabContext* context,
     SessionID::id_type id,
-    int host_desktop_type,
     WindowOpenDisposition disposition) {
   Entries::iterator entry_iterator = GetEntryIteratorById(id);
   if (entry_iterator == entries_.end())
     // Don't hoark here, we allow an invalid id.
     return std::vector<LiveTab*>();
 
   if (observer_)
     observer_->OnRestoreEntryById(id, entry_iterator);
   restoring_ = true;
   Entry* entry = *entry_iterator;
 
   // If the entry's ID does not match the ID that is being restored, then the
   // entry is a window from which a single tab will be restored.
   bool restoring_tab_in_window = entry->id != id;
 
   if (!restoring_tab_in_window) {
     entries_.erase(entry_iterator);
     entry_iterator = entries_.end();
   }
 
   // |context| will be NULL in cases where one isn't already available (eg,
   // when invoked on Mac OS X with no windows open). In this case, create a
   // new browser into which we restore the tabs.
   std::vector<LiveTab*> live_tabs;
   if (entry->type == TabRestoreService::TAB) {
     Tab* tab = static_cast<Tab*>(entry);
     LiveTab* restored_tab = NULL;
-    context = RestoreTab(*tab, context, host_desktop_type, disposition,
-                         &restored_tab);
+    context = RestoreTab(*tab, context, disposition, &restored_tab);
     live_tabs.push_back(restored_tab);
     context->ShowBrowserWindow();
   } else if (entry->type == TabRestoreService::WINDOW) {
     LiveTabContext* current_context = context;
     Window* window = static_cast<Window*>(entry);
 
     // When restoring a window, either the entire window can be restored, or a
     // single tab within it. If the entry's ID matches the one to restore, then
     // the entire window will be restored.
     if (!restoring_tab_in_window) {
-      context =
-          client_->CreateLiveTabContext(host_desktop_type, window->app_name);
+      context = client_->CreateLiveTabContext(window->app_name);
       for (size_t tab_i = 0; tab_i < window->tabs.size(); ++tab_i) {
         const Tab& tab = window->tabs[tab_i];
         LiveTab* restored_tab = context->AddRestoredTab(
             tab.navigations, context->GetTabCount(),
             tab.current_navigation_index, tab.extension_app_id,
             static_cast<int>(tab_i) == window->selected_tab_index, tab.pinned,
             tab.from_last_session, tab.platform_data.get(),
             tab.user_agent_override);
         if (restored_tab) {
           restored_tab->LoadIfNecessary();
           client_->OnTabRestored(
               tab.navigations.at(tab.current_navigation_index).virtual_url());
           live_tabs.push_back(restored_tab);
         }
       }
       // All the window's tabs had the same former browser_id.
       if (window->tabs[0].has_browser()) {
         UpdateTabBrowserIDs(window->tabs[0].browser_id,
                             context->GetSessionID().id());
       }
     } else {
       // Restore a single tab from the window. Find the tab that matches the ID
       // in the window and restore it.
       for (std::vector<Tab>::iterator tab_i = window->tabs.begin();
            tab_i != window->tabs.end(); ++tab_i) {
         const Tab& tab = *tab_i;
         if (tab.id == id) {
           LiveTab* restored_tab = NULL;
-          context = RestoreTab(tab, context, host_desktop_type, disposition,
-                               &restored_tab);
+          context = RestoreTab(tab, context, disposition, &restored_tab);
           live_tabs.push_back(restored_tab);
           window->tabs.erase(tab_i);
           // If restoring the tab leaves the window with nothing else, delete it
           // as well.
           if (!window->tabs.size()) {
             entries_.erase(entry_iterator);
             delete entry;
           } else {
             // Update the browser ID of the rest of the tabs in the window so if
             // any one is restored, it goes into the same window as the tab
@@ skipping 141 matching lines @@
   // Delegate may be NULL during unit tests.
   if (context) {
     tab->browser_id = context->GetSessionID().id();
     tab->pinned = context->IsTabPinned(tab->tabstrip_index);
   }
 }
 
 LiveTabContext* TabRestoreServiceHelper::RestoreTab(
     const Tab& tab,
     LiveTabContext* context,
-    int host_desktop_type,
     WindowOpenDisposition disposition,
     LiveTab** live_tab) {
   LiveTab* restored_tab;
   if (disposition == CURRENT_TAB && context) {
     restored_tab = context->ReplaceRestoredTab(
         tab.navigations, tab.current_navigation_index, tab.from_last_session,
         tab.extension_app_id, tab.platform_data.get(), tab.user_agent_override);
   } else {
     // We only respsect the tab's original browser if there's no disposition.
     if (disposition == UNKNOWN && tab.has_browser()) {
-      context =
-          client_->FindLiveTabContextWithID(tab.browser_id, host_desktop_type);
+      context = client_->FindLiveTabContextWithID(tab.browser_id);
     }
 
     int tab_index = -1;
 
     // |context| will be NULL in cases where one isn't already available (eg,
     // when invoked on Mac OS X with no windows open). In this case, create a
     // new browser into which we restore the tabs.
     if (context && disposition != NEW_WINDOW) {
       tab_index = tab.tabstrip_index;
     } else {
-      context = client_->CreateLiveTabContext(host_desktop_type, std::string());
+      context = client_->CreateLiveTabContext(std::string());
       if (tab.has_browser())
         UpdateTabBrowserIDs(tab.browser_id, context->GetSessionID().id());
     }
 
     // Place the tab at the end if the tab index is no longer valid or
     // we were passed a specific disposition.
     if (tab_index < 0 || tab_index > context->GetTabCount() ||
         disposition != UNKNOWN) {
       tab_index = context->GetTabCount();
     }
@@ skipping 95 matching lines @@
         tab->browser_id = new_id;
     }
   }
 }
 
 base::Time TabRestoreServiceHelper::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : base::Time::Now();
 }
 
 }  // namespace sessions