Fix user agent override restore pipeline

chrome/browser/sessions/session_restore_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 "base/command_line.h"
 #include "base/file_path.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/first_run/first_run.h"
@@ skipping 374 matching lines @@
   TabNavigation nav2(0, url2, content::Referrer(), ASCIIToUTF16("two"),
         std::string(), content::PAGE_TRANSITION_TYPED);
 
   // Set up the restore data.
   SessionTab tab;
   tab.tab_visual_index = 0;
   tab.current_navigation_index = 1;
   tab.pinned = false;
   tab.navigations.push_back(nav1);
   tab.navigations.push_back(nav2);
+  tab.user_agent_override = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.19"
+      " (KHTML, like Gecko) Chrome/18.0.1025.45 Safari/535.19";
 
   ASSERT_EQ(1, browser()->tab_count());
 
   // Restore in the current tab.
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     SessionRestore::RestoreForeignSessionTab(
         chrome::GetActiveWebContents(browser()), tab, CURRENT_TAB);
     observer.Wait();
   }
   ASSERT_EQ(1, browser()->tab_count());
-  VerifyNavigationEntries(
-      chrome::GetWebContentsAt(browser(), 0)->GetController(), url1, url2);
+  content::WebContents* web_contents = chrome::GetWebContentsAt(browser(), 0);
+  VerifyNavigationEntries(web_contents->GetController(), url1, url2);
+  ASSERT_EQ(tab.user_agent_override, web_contents->GetUserAgentOverride());
 
   // Restore in a new tab.
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     SessionRestore::RestoreForeignSessionTab(
         chrome::GetActiveWebContents(browser()), tab, NEW_BACKGROUND_TAB);
     observer.Wait();
   }
   ASSERT_EQ(2, browser()->tab_count());
   ASSERT_EQ(0, browser()->active_index());
-  VerifyNavigationEntries(
-      chrome::GetWebContentsAt(browser(), 1)->GetController(), url1, url2);
+  web_contents = chrome::GetWebContentsAt(browser(), 1);
+  VerifyNavigationEntries(web_contents->GetController(), url1, url2);
+  ASSERT_EQ(tab.user_agent_override, web_contents->GetUserAgentOverride());
 
   // Restore in a new window.
   ui_test_utils::BrowserAddedObserver browser_observer;
   SessionRestore::RestoreForeignSessionTab(
       chrome::GetActiveWebContents(browser()), tab, NEW_WINDOW);
   Browser* new_browser = browser_observer.WaitForSingleNewBrowser();
 
   ASSERT_EQ(1, new_browser->tab_count());
-  VerifyNavigationEntries(
-      chrome::GetWebContentsAt(new_browser, 0)->GetController(), url1, url2);
+  web_contents = chrome::GetWebContentsAt(new_browser, 0);
+  VerifyNavigationEntries(web_contents->GetController(), url1, url2);
+  ASSERT_EQ(tab.user_agent_override, web_contents->GetUserAgentOverride());
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignSession) {
   Profile* profile = browser()->profile();
 
   GURL url1("http://google.com");
   GURL url2("http://google2.com");
   TabNavigation nav1(0, url1, content::Referrer(), ASCIIToUTF16("one"),
         std::string(), content::PAGE_TRANSITION_TYPED);
   TabNavigation nav2(0, url2, content::Referrer(), ASCIIToUTF16("two"),
         std::string(), content::PAGE_TRANSITION_TYPED);
+  nav1.set_is_overriding_user_agent(false);
+  nav2.set_is_overriding_user_agent(true);
 
   // Set up the restore data -- one window with two tabs.
   std::vector<const SessionWindow*> session;
   SessionWindow window;
   SessionTab tab1;
   tab1.tab_visual_index = 0;
   tab1.current_navigation_index = 0;
   tab1.pinned = true;
   tab1.navigations.push_back(nav1);
+  tab1.user_agent_override = "user_agent_override";
   window.tabs.push_back(&tab1);
 
   SessionTab tab2;
   tab2.tab_visual_index = 1;
   tab2.current_navigation_index = 0;
   tab2.pinned = false;
   tab2.navigations.push_back(nav2);
+  tab2.user_agent_override = "user_agent_override_2";
   window.tabs.push_back(&tab2);
 
   session.push_back(static_cast<const SessionWindow*>(&window));
   ui_test_utils::BrowserAddedObserver window_observer;
   SessionRestore::RestoreForeignSessionWindows(
       profile, session.begin(), session.end());
   Browser* new_browser = window_observer.WaitForSingleNewBrowser();
   ASSERT_TRUE(new_browser);
   ASSERT_EQ(2u, BrowserList::size());
   ASSERT_EQ(2, new_browser->tab_count());
 
-  ASSERT_EQ(url1, chrome::GetWebContentsAt(new_browser, 0)->GetURL());
-  ASSERT_EQ(url2, chrome::GetWebContentsAt(new_browser, 1)->GetURL());
+  content::WebContents* web_contents_1 =
+      chrome::GetWebContentsAt(new_browser, 0);
+  content::WebContents* web_contents_2 =
+      chrome::GetWebContentsAt(new_browser, 1);
+  ASSERT_EQ(url1, web_contents_1->GetURL());
+  ASSERT_EQ(url2, web_contents_2->GetURL());
+
+  // Check user agent override state.
+  ASSERT_EQ(tab1.user_agent_override, web_contents_1->GetUserAgentOverride());
+  ASSERT_EQ(tab2.user_agent_override, web_contents_2->GetUserAgentOverride());
+
+  content::NavigationEntry* entry =
+      web_contents_1->GetController().GetActiveEntry();
+  ASSERT_TRUE(entry);
+  ASSERT_EQ(nav1.is_overriding_user_agent(), entry->GetIsOverridingUserAgent());
+
+  entry = web_contents_2->GetController().GetActiveEntry();
+  ASSERT_TRUE(entry);
+  ASSERT_EQ(nav2.is_overriding_user_agent(), entry->GetIsOverridingUserAgent());
 
   // The SessionWindow destructor deletes the tabs, so we have to clear them
   // here to avoid a crash.
   window.tabs.clear();
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, Basic) {
   ui_test_utils::NavigateToURL(browser(), url1_);
   ui_test_utils::NavigateToURL(browser(), url2_);
 
@@ skipping 236 matching lines @@
   int expected_process_count = RenderProcessHostCount();
 
   // Restart.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 3);
 
   ASSERT_EQ(3, new_browser->tab_count());
 
   ASSERT_EQ(expected_process_count, RenderProcessHostCount());
 }
 
+// Test that changing the user agent override will persist it to disk.
+IN_PROC_BROWSER_TEST_F(SessionRestoreTest, PersistAndRestoreUserAgentOverride) {
+  // Create a tab with an overridden user agent.
+  ui_test_utils::NavigateToURL(browser(), url1_);
+  ASSERT_EQ(0, browser()->active_index());
+  chrome::GetWebContentsAt(browser(), 0)->SetUserAgentOverride("override");
+
+  // Create a tab without an overridden user agent.
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), url2_, NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+  ASSERT_EQ(1, browser()->active_index());
+
+  // Kill the original browser then open a new one to trigger a restore.
+  Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
+  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(2, new_browser->tab_count());
+  ASSERT_EQ(1, new_browser->active_index());
+
+  // Confirm that the user agent overrides are properly set.
+  EXPECT_EQ("override",
+      chrome::GetWebContentsAt(new_browser, 0)->GetUserAgentOverride());
+  EXPECT_EQ("",
+      chrome::GetWebContentsAt(new_browser, 1)->GetUserAgentOverride());
+}
+
 // Regression test for crbug.com/125958. When restoring a pinned selected tab in
 // a setting where there are existing tabs, the selected index computation was
 // wrong, leading to the wrong tab getting selected, DCHECKs firing, and the
 // pinned tab not getting loaded.
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestorePinnedSelectedTab) {
   // Create a pinned tab.
   ui_test_utils::NavigateToURL(browser(), url1_);
   browser()->tab_strip_model()->SetTabPinned(0, true);
   ASSERT_EQ(0, browser()->active_index());
   // Create a nonpinned tab.
@@ skipping 43 matching lines @@
   ASSERT_EQ(1u, BrowserList::size());
   ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
   content::NavigationController* new_controller =
       &chrome::GetActiveWebContents(new_browser)->GetController();
   ASSERT_TRUE(new_controller->GetDefaultSessionStorageNamespace());
   std::string restored_session_storage_persistent_id =
       new_controller->GetDefaultSessionStorageNamespace()->persistent_id();
   EXPECT_EQ(session_storage_persistent_id,
             restored_session_storage_persistent_id);
 }