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

chrome/browser/ui/ash/chrome_shell_delegate.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/ash/chrome_shell_delegate.h"
 
 #include "ash/ash_switches.h"
 #include "ash/host/root_window_host_factory.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/magnifier/magnifier_constants.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
+#include "chrome/browser/sessions/tab_restore_service_observer.h"
 #include "chrome/browser/ui/app_list/app_list_view_delegate.h"
 #include "chrome/browser/ui/ash/app_list/app_list_controller_ash.h"
 #include "chrome/browser/ui/ash/ash_keyboard_controller_proxy.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/launcher_context_menu.h"
 #include "chrome/browser/ui/ash/session_state_delegate.h"
 #include "chrome/browser/ui/ash/user_action_handler.h"
 #include "chrome/browser/ui/ash/window_positioner.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
@@ skipping 14 matching lines @@
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/default_pinned_apps_field_trial.h"
 #endif
 
 // static
 ChromeShellDelegate* ChromeShellDelegate::instance_ = NULL;
 
+namespace {
+
+void RestoreTabUsingProfile(Profile* profile) {
+  TabRestoreService* service = TabRestoreServiceFactory::GetForProfile(profile);
+  service->RestoreMostRecentEntry(NULL, chrome::HOST_DESKTOP_TYPE_ASH);
+}
+
+}  // namespace
+
+// TabRestoreHelper is used to restore a tab. In particular when the user
+// attempts to a restore a tab if the TabRestoreService hasn't finished loading
+// this waits for it. Once the TabRestoreService finishes loading the tab is
+// restored.
+class ChromeShellDelegate::TabRestoreHelper : public TabRestoreServiceObserver {
+ public:
+  TabRestoreHelper(ChromeShellDelegate* delegate,
+                   Profile* profile,
+                   TabRestoreService* service)
+      : delegate_(delegate),
+        profile_(profile),
+        tab_restore_service_(service) {
+    tab_restore_service_->AddObserver(this);
+  }
+
+  virtual ~TabRestoreHelper() {
+    tab_restore_service_->RemoveObserver(this);
+  }
+
+  TabRestoreService* tab_restore_service() { return tab_restore_service_; }
+
+  virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE {
+  }
+  virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE {
+    // This destroys us.
+    delegate_->tab_restore_helper_.reset();
+  }
+
+  virtual void TabRestoreServiceLoaded(TabRestoreService* service) OVERRIDE {
+    RestoreTabUsingProfile(profile_);
+    // This destroys us.
+    delegate_->tab_restore_helper_.reset();
+  }
+
+ private:
+  ChromeShellDelegate* delegate_;
+  Profile* profile_;
+  TabRestoreService* tab_restore_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabRestoreHelper);
+};
+
 ChromeShellDelegate::ChromeShellDelegate()
     : window_positioner_(new ash::WindowPositioner()),
       weak_factory_(this),
       launcher_delegate_(NULL) {
   instance_ = this;
   PlatformInit();
 }
 
 ChromeShellDelegate::~ChromeShellDelegate() {
   if (instance_ == this)
@@ skipping 73 matching lines @@
 
   // Get out of fullscreen when in fullscreen mode.
   if (ash::wm::IsWindowFullscreen(window)) {
     ToggleFullscreen();
     return;
   }
   ash::wm::ToggleMaximizedWindow(window);
 }
 
 void ChromeShellDelegate::RestoreTab() {
-  Browser* browser = GetTargetBrowser();
-  // Do not restore tabs while in the incognito mode.
-  if (browser->profile()->IsOffTheRecord())
+  if (tab_restore_helper_.get()) {
+    DCHECK(!tab_restore_helper_->tab_restore_service()->IsLoaded());
+    return;
+  }
+
+  Browser* browser = chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow());

[James Cook, 2013/05/09 16:36:31]

I think the old code will create a new browser window if none are open (via
GetTargetBrowser).  I think we want to keep that behavior, since the user can
hit Ctrl-Shift-T with no windows open.

[sky, 2013/05/09 16:42:12]

This is done at line 65 now. Specifically:
service->RestoreMostRecentEntry(NULL, chrome::HOST_DESKTOP_TYPE_ASH);
does that.

GetTargetBrowser is hugely problematic (177542, which keeps getting pushed). The
old code could create a browser and never end up using it (it would not be shown
either).

[James Cook, 2013/05/09 16:48:30]

Ah, I didn't notice RestoreMostRecentEntry did that.  Damn, I thought I found a
bug in your code, which is so rare I was getting excited. :-)

+  Profile* profile = browser ? browser->profile() : NULL;
+  if (!profile)
+    profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+  if (profile->IsOffTheRecord())
     return;
   TabRestoreService* service =
-      TabRestoreServiceFactory::GetForProfile(browser->profile());
+      TabRestoreServiceFactory::GetForProfile(profile);
   if (!service)
     return;
+
   if (service->IsLoaded()) {
-    chrome::RestoreTab(browser);
+    RestoreTabUsingProfile(profile);
   } else {
+    tab_restore_helper_.reset(new TabRestoreHelper(this, profile, service));
     service->LoadTabsFromLastSession();
-    // LoadTabsFromLastSession is asynchronous, so TabRestoreService has not
-    // finished loading the entries at this point. Wait for next event cycle
-    // which loads the restored tab entries.
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromeShellDelegate::RestoreTab,
-                   weak_factory_.GetWeakPtr()));
   }
 }
 
 void ChromeShellDelegate::ShowTaskManager() {
   chrome::OpenTaskManager(NULL, false);
 }
 
 content::BrowserContext* ChromeShellDelegate::GetCurrentBrowserContext() {
   return ProfileManager::GetDefaultProfile();
 }
@@ skipping 195 matching lines @@
     return browser;
   return chrome::FindOrCreateTabbedBrowser(
       ProfileManager::GetDefaultProfileOrOffTheRecord(),
       chrome::HOST_DESKTOP_TYPE_ASH);
 }
 
 keyboard::KeyboardControllerProxy*
     ChromeShellDelegate::CreateKeyboardControllerProxy() {
   return new AshKeyboardControllerProxy();
 }