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

chrome/browser/sessions/persistent_tab_restore_service_browsertest.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 "base/compiler_specific.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
+#include "chrome/browser/sessions/tab_restore_service_observer.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/chrome_render_view_test.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sessions/serialized_navigation_entry_test_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
@@ skipping 137 matching lines @@
   GURL url2_;
   GURL url3_;
   std::string user_agent_override_;
   scoped_ptr<PersistentTabRestoreService> service_;
   PersistentTabRestoreTimeFactory* time_factory_;
   content::RenderViewTest::RendererWebKitPlatformSupportImplNoSandbox
       webkit_platform_support_;
   content::TestBrowserThread ui_thread_;
 };
 
+namespace {
+
+class TestTabRestoreServiceObserver : public TabRestoreServiceObserver {
+ public:
+  TestTabRestoreServiceObserver() : got_loaded_(false) {}
+
+  void clear_got_loaded() { got_loaded_ = false; }
+  bool got_loaded() const { return got_loaded_; }
+
+  // TabRestoreServiceObserver:
+  virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE {
+  }
+  virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE {
+  }
+  virtual void TabRestoreServiceLoaded(TabRestoreService* service) OVERRIDE {
+    got_loaded_ = true;
+  }
+
+ private:
+  // Was TabRestoreServiceLoaded() invoked?
+  bool got_loaded_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestTabRestoreServiceObserver);
+};
+
+}  // namespace
+
 TEST_F(PersistentTabRestoreServiceTest, Basic) {
   AddThreeNavigations();
 
   // Have the service record the tab.
   service_->CreateHistoricalTab(web_contents(), -1);
 
   // Make sure an entry was created.
   ASSERT_EQ(1U, service_->entries().size());
 
   // Make sure the entry matches.
@@ skipping 183 matching lines @@
   ASSERT_EQ(1U, service_->entries().size());
 }
 
 // Makes sure we load the previous session as necessary.
 TEST_F(PersistentTabRestoreServiceTest, LoadPreviousSession) {
   CreateSessionServiceWithOneWindow(false);
 
   SessionServiceFactory::GetForProfile(profile())->
       MoveCurrentSessionToLastSession();
 
+  EXPECT_FALSE(service_->IsLoaded());
+
+  TestTabRestoreServiceObserver observer;
+  service_->AddObserver(&observer);
   service_->LoadTabsFromLastSession();
+  EXPECT_TRUE(observer.got_loaded());
+  service_->RemoveObserver(&observer);
 
   // Make sure we get back one entry with one tab whose url is url1.
   ASSERT_EQ(1U, service_->entries().size());
   TabRestoreService::Entry* entry2 = service_->entries().front();
   ASSERT_EQ(TabRestoreService::WINDOW, entry2->type);
   TabRestoreService::Window* window =
       static_cast<TabRestoreService::Window*>(entry2);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->timestamp.ToInternalValue());
   EXPECT_EQ(0, window->selected_tab_index);
@@ skipping 302 matching lines @@
     NavigateAndCommit(
         GURL(base::StringPrintf("http://%d", static_cast<int>(i))));
     service_->CreateHistoricalTab(web_contents(), -1);
   }
 
   EXPECT_EQ(max_entries, service_->entries().size());
   // This should not crash.
   service_->LoadTabsFromLastSession();
   EXPECT_EQ(max_entries, service_->entries().size());
 }
+
+// Makes sure invoking LoadTabsFromLastSession() when the max number of entries
+// have been added results in IsLoaded() returning true and notifies observers.
+TEST_F(PersistentTabRestoreServiceTest, GoToLoadedWhenHaveMaxEntries) {
+  const size_t max_entries = kMaxEntries;
+  for (size_t i = 0; i < max_entries + 5; i++) {
+    NavigateAndCommit(
+        GURL(base::StringPrintf("http://%d", static_cast<int>(i))));
+    service_->CreateHistoricalTab(web_contents(), -1);
+  }
+
+  EXPECT_FALSE(service_->IsLoaded());
+  TestTabRestoreServiceObserver observer;
+  service_->AddObserver(&observer);
+  EXPECT_EQ(max_entries, service_->entries().size());
+  service_->LoadTabsFromLastSession();
+  EXPECT_TRUE(observer.got_loaded());
+  EXPECT_TRUE(service_->IsLoaded());
+  service_->RemoveObserver(&observer);
+}