Fixes couple of bugs triggered on chromeos when restoring a tab:

chrome/browser/sessions/persistent_tab_restore_service.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/sessions/persistent_tab_restore_service.h"
 
 #include <cstring>  // memcpy
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 300 matching lines @@
   ScheduleCommand(CreateRestoredEntryCommand(id));
 }
 
 void PersistentTabRestoreService::Delegate::OnAddEntry() {
   // Start the save timer, when it fires we'll generate the commands.
   StartSaveTimer();
   entries_to_write_++;
 }
 
 void PersistentTabRestoreService::Delegate::LoadTabsFromLastSession() {
-  if (load_state_ != NOT_LOADED ||
-      tab_restore_service_helper_->entries().size() == kMaxEntries)
+  if (load_state_ != NOT_LOADED)
     return;
 
+  if (tab_restore_service_helper_->entries().size() == kMaxEntries) {
+    // We already have the max number of entries we can take. There is no point
+    // in attempting to load since we'll just drop the results. Skip to loaded.
+    load_state_ = (LOADING | LOADED_LAST_SESSION | LOADED_LAST_TABS);
+    LoadStateChanged();
+    return;
+  }
+
 #if !defined(ENABLE_SESSION_SERVICE)
   // If sessions are not stored in the SessionService, default to
   // |LOADED_LAST_SESSION| state.
   load_state_ = LOADING | LOADED_LAST_SESSION;
 #else
   load_state_ = LOADING;
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfile(profile());
   Profile::ExitType exit_type = profile()->GetLastSessionExitType();
@@ skipping 476 matching lines @@
     // Still waiting on previous session or previous tabs.
     return;
   }
 
   // We're done loading.
   load_state_ ^= LOADING;
 
   const Entries& entries = tab_restore_service_helper_->entries();
   if (staging_entries_.empty() || entries.size() >= kMaxEntries) {
     staging_entries_.clear();
+    tab_restore_service_helper_->NotifyLoaded();
     return;
   }
 
   if (staging_entries_.size() + entries.size() > kMaxEntries) {
     // If we add all the staged entries we'll end up with more than
     // kMaxEntries. Delete entries such that we only end up with at most
     // kMaxEntries.
     int surplus = kMaxEntries - entries.size();
     CHECK_LE(0, surplus);
     CHECK_GE(static_cast<int>(staging_entries_.size()), surplus);
@@ skipping 12 matching lines @@
   // it doesn't delete them.
   staging_entries_.weak_clear();
 
   // Make it so we rewrite all the tabs. We need to do this otherwise we won't
   // correctly write out the entries when Save is invoked (Save starts from
   // the front, not the end and we just added the entries to the end).
   entries_to_write_ = staging_entries_.size();
 
   tab_restore_service_helper_->PruneEntries();
   tab_restore_service_helper_->NotifyTabsChanged();
+
+  tab_restore_service_helper_->NotifyLoaded();
 }
 
 void PersistentTabRestoreService::Delegate::RemoveEntryByID(
     SessionID::id_type id,
     IDToEntry* id_to_entry,
     std::vector<TabRestoreService::Entry*>* entries) {
   // Look for the entry in the map. If it is present, erase it from both
   // collections and return.
   IDToEntry::iterator i = id_to_entry->find(id);
   if (i != id_to_entry->end()) {
@@ skipping 109 matching lines @@
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 ProfileKeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* profile) const {
   return new PersistentTabRestoreService(static_cast<Profile*>(profile), NULL);
 }