Merge lp:~osomon/oxide/backport-42-patch-for-isError into lp:oxide/1.5

[Olivier Tilloy]

Backport commit 7431bb2983db683dcc4556e1918556254c3d5589 from upstream chromium branch 42 and corresponding unit tests.

[Chris Coulson (chrisccoulson)]

Thanks - I wasn't sure if you'd get a chance to do it today, so I've merged this in to 1.5

review: Approve

=== added file 'patches/bug1423531.patch'
--- patches/bug1423531.patch	1970-01-01 00:00:00 +0000
+++ patches/bug1423531.patch	2015-03-04 14:35:28 +0000
@@ -0,0 +1,202 @@
+# Description: backport commit 7431bb2983db683dcc4556e1918556254c3d5589
+#  from the 42 branch to fix https://launchpad.net/bugs/1423531
+# Author: Olivier Tilloy <[e-mail]>
+
+diff --git a/chrome/browser/ui/zoom/zoom_controller_browsertest.cc b/chrome/browser/ui/zoom/zoom_controller_browsertest.cc
+--- a/chrome/browser/ui/zoom/zoom_controller_browsertest.cc
++++ b/chrome/browser/ui/zoom/zoom_controller_browsertest.cc
+@@ -8,6 +8,7 @@
+ #include "base/process/kill.h"
+ #include "chrome/browser/profiles/profile.h"
+ #include "chrome/browser/ui/browser.h"
++#include "chrome/browser/ui/browser_commands.h"
+ #include "chrome/browser/ui/tabs/tab_strip_model.h"
+ #include "chrome/browser/ui/webui/signin/login_ui_test_utils.h"
+ #include "chrome/browser/ui/zoom/chrome_zoom_level_prefs.h"
+@@ -140,6 +141,57 @@
+   EXPECT_FLOAT_EQ(new_zoom_level, zoom_controller->GetZoomLevel());
+ }
+ 
++IN_PROC_BROWSER_TEST_F(ZoomControllerBrowserTest,
++                       ErrorPagesCanZoomAfterTabRestore) {
++  // This url is meant to cause a network error page to be loaded.
++  // Tests can't reach the network, so this test should continue
++  // to work even if the domain listed is someday registered.
++  GURL url("http://kjfhkjsdf.com");
++
++  TabStripModel* tab_strip = browser()->tab_strip_model();
++  ASSERT_TRUE(tab_strip);
++
++  ui_test_utils::NavigateToURLWithDisposition(
++      browser(), url, NEW_FOREGROUND_TAB,
++      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
++  {
++    content::WebContents* web_contents = tab_strip->GetActiveWebContents();
++
++    EXPECT_EQ(
++        content::PAGE_TYPE_ERROR,
++        web_contents->GetController().GetLastCommittedEntry()->GetPageType());
++
++    content::WebContentsDestroyedWatcher destroyed_watcher(web_contents);
++    tab_strip->CloseWebContentsAt(tab_strip->active_index(),
++                                  TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
++    destroyed_watcher.Wait();
++  }
++  EXPECT_EQ(1, tab_strip->count());
++
++  content::WebContentsAddedObserver new_web_contents_observer;
++  chrome::RestoreTab(browser());
++  content::WebContents* web_contents =
++      new_web_contents_observer.GetWebContents();
++  content::WaitForLoadStop(web_contents);
++
++  EXPECT_EQ(2, tab_strip->count());
++
++  EXPECT_EQ(
++      content::PAGE_TYPE_ERROR,
++      web_contents->GetController().GetLastCommittedEntry()->GetPageType());
++
++  ZoomController* zoom_controller =
++      ZoomController::FromWebContents(web_contents);
++
++  double old_zoom_level = zoom_controller->GetZoomLevel();
++  double new_zoom_level = old_zoom_level + 0.5;
++
++  // The following attempt to change the zoom level for an error page should
++  // fail.
++  zoom_controller->SetZoomLevel(new_zoom_level);
++  EXPECT_FLOAT_EQ(new_zoom_level, zoom_controller->GetZoomLevel());
++}
++
+ IN_PROC_BROWSER_TEST_F(ZoomControllerBrowserTest, Observe) {
+   content::WebContents* web_contents =
+       browser()->tab_strip_model()->GetActiveWebContents();
+diff --git a/content/browser/frame_host/navigation_controller_impl.cc b/content/browser/frame_host/navigation_controller_impl.cc
+--- a/content/browser/frame_host/navigation_controller_impl.cc
++++ b/content/browser/frame_host/navigation_controller_impl.cc
+@@ -1050,10 +1050,6 @@
+        pending_entry_->site_instance() == rfh->GetSiteInstance())) {
+     new_entry = new NavigationEntryImpl(*pending_entry_);
+ 
+-    // Don't use the page type from the pending entry. Some interstitial page
+-    // may have set the type to interstitial. Once we commit, however, the page
+-    // type must always be normal.
+-    new_entry->set_page_type(PAGE_TYPE_NORMAL);
+     update_virtual_url = new_entry->update_virtual_url_with_url();
+   } else {
+     new_entry = new NavigationEntryImpl;
+@@ -1074,8 +1070,12 @@
+     update_virtual_url = needs_update;
+   }
+ 
+-  if (params.url_is_unreachable)
+-    new_entry->set_page_type(PAGE_TYPE_ERROR);
++  // Don't use the page type from the pending entry. Some interstitial page
++  // may have set the type to interstitial. Once we commit, however, the page
++  // type must always be normal or error.
++  new_entry->set_page_type(params.url_is_unreachable ? PAGE_TYPE_ERROR
++                                                     : PAGE_TYPE_NORMAL);
++
+   new_entry->SetURL(params.url);
+   if (update_virtual_url)
+     UpdateVirtualURLToURL(new_entry, params.url);
+@@ -1126,6 +1126,8 @@
+   NavigationEntryImpl* entry = entries_[entry_index].get();
+ 
+   // The URL may have changed due to redirects.
++  entry->set_page_type(params.url_is_unreachable ? PAGE_TYPE_ERROR
++                                                 : PAGE_TYPE_NORMAL);
+   entry->SetURL(params.url);
+   entry->SetReferrer(params.referrer);
+   if (entry->update_virtual_url_with_url())
+@@ -1178,6 +1180,8 @@
+   existing_entry->set_unique_id(pending_entry_->GetUniqueID());
+ 
+   // The URL may have changed due to redirects.
++  existing_entry->set_page_type(params.url_is_unreachable ? PAGE_TYPE_ERROR
++                                                          : PAGE_TYPE_NORMAL);
+   if (existing_entry->update_virtual_url_with_url())
+     UpdateVirtualURLToURL(existing_entry, params.url);
+   existing_entry->SetURL(params.url);
+@@ -1204,6 +1208,8 @@
+   // entry and it will be the same page as the new navigation (minus the
+   // reference fragments, of course).  We'll update the URL of the existing
+   // entry without pruning the forward history.
++  existing_entry->set_page_type(params.url_is_unreachable ? PAGE_TYPE_ERROR
++                                                          : PAGE_TYPE_NORMAL);
+   existing_entry->SetURL(params.url);
+   if (existing_entry->update_virtual_url_with_url())
+     UpdateVirtualURLToURL(existing_entry, params.url);
+diff --git a/content/browser/frame_host/navigation_controller_impl_unittest.cc b/content/browser/frame_host/navigation_controller_impl_unittest.cc
+--- a/content/browser/frame_host/navigation_controller_impl_unittest.cc
++++ b/content/browser/frame_host/navigation_controller_impl_unittest.cc
+@@ -28,6 +28,7 @@
+ #include "content/public/browser/web_contents_observer.h"
+ #include "content/public/common/content_switches.h"
+ #include "content/public/common/page_state.h"
++#include "content/public/common/page_type.h"
+ #include "content/public/common/url_constants.h"
+ #include "content/public/test/mock_render_process_host.h"
+ #include "content/public/test/test_notification_tracker.h"
+@@ -4456,4 +4457,61 @@
+   EXPECT_EQ(0, delegate->repost_form_warning_count());
+ }
+ 
++TEST_F(NavigationControllerTest, UnreachableURLGivesErrorPage) {
++  GURL url("http://foo");
++  FrameHostMsg_DidCommitProvisionalLoad_Params params;
++  params.page_id = 1;
++  params.url = url;
++  params.transition = ui::PAGE_TRANSITION_LINK;
++  params.gesture = NavigationGestureUser;
++  params.page_state = PageState::CreateFromURL(url);
++  params.was_within_same_page = false;
++  params.is_post = true;
++  params.post_id = 2;
++  params.url_is_unreachable = true;
++  // Navigate to new page
++  {
++    LoadCommittedDetails details;
++    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
++    EXPECT_EQ(PAGE_TYPE_ERROR,
++              controller_impl().GetLastCommittedEntry()->GetPageType());
++    EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, details.type);
++  }
++
++  // Navigate to existing page.
++  {
++    LoadCommittedDetails details;
++    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
++    EXPECT_EQ(PAGE_TYPE_ERROR,
++              controller_impl().GetLastCommittedEntry()->GetPageType());
++    EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, details.type);
++  }
++
++  // Navigate to same page.
++  // Note: The call to LoadURL() creates a pending entry in order to trigger the
++  // same-page transition.
++  controller_impl().LoadURL(
++      url, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
++  params.transition = ui::PAGE_TRANSITION_TYPED;
++  {
++    LoadCommittedDetails details;
++    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
++    EXPECT_EQ(PAGE_TYPE_ERROR,
++              controller_impl().GetLastCommittedEntry()->GetPageType());
++    EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, details.type);
++  }
++
++  // Navigate in page.
++  params.url = GURL("http://foo#foo");
++  params.transition = ui::PAGE_TRANSITION_LINK;
++  params.was_within_same_page = true;
++  {
++    LoadCommittedDetails details;
++    controller_impl().RendererDidNavigate(main_test_rfh(), params, &details);
++    EXPECT_EQ(PAGE_TYPE_ERROR,
++              controller_impl().GetLastCommittedEntry()->GetPageType());
++    EXPECT_EQ(NAVIGATION_TYPE_IN_PAGE, details.type);
++  }
++}
++
+ }  // namespace content
 
=== modified file 'patches/series'
--- patches/series	2015-02-06 22:41:44 +0000
+++ patches/series	2015-03-04 14:35:28 +0000
@@ -29,3 +29,4 @@
 allow-os-override-for-gpu-manager.patch
 viewport-min-width.patch
 dont-hide-desktop-scrollbars-without-pinch-viewport.patch
+bug1423531.patch
 
=== modified file 'qt/tests/qmltests/api/tst_WebView_loading.qml'
--- qt/tests/qmltests/api/tst_WebView_loading.qml	2015-01-13 12:31:34 +0000
+++ qt/tests/qmltests/api/tst_WebView_loading.qml	2015-03-04 14:35:28 +0000
@@ -162,6 +162,29 @@
       compare(spy.count, 1,
               "WebView.loading should have changed twice during the load");
       compare(expectedLoadEvents.length, 0, "Some load events are missing");
+
+      // Verify that reloading a page that triggered an error
+      // generates the same sequence of load events
+      spy.clear();
+      expectedLoadEvents = [
+        { type: LoadEvent.TypeStarted, url: url, loading: true },
+        { type: LoadEvent.TypeFailed, url: url, loading: true },
+        { type: LoadEvent.TypeCommitted, url: url, error: true, loading: true }
+      ];
+      webView.reload();
+
+      verify(webView.loading,
+             "WebView.loading should be true once we start loading");
+      compare(spy.count, 1);
+
+      spy.clear();
+      spy.wait();
+
+      verify(!webView.loading,
+             "WebView.loading should be false after we finish loading");
+      compare(spy.count, 1,
+              "WebView.loading should have changed twice during the load");
+      compare(expectedLoadEvents.length, 0, "Some load events are missing");
     }
 
     function test_WebView_loading5_redirection() {
 
=== modified file 'qt/tests/qmltests/api/tst_WebView_save_restore_state.qml'
--- qt/tests/qmltests/api/tst_WebView_save_restore_state.qml	2014-11-20 12:37:10 +0000
+++ qt/tests/qmltests/api/tst_WebView_save_restore_state.qml	2015-03-04 14:35:28 +0000
@@ -149,4 +149,44 @@
             "document.querySelector('#textInput').value") == "Te$t"; });
     restored.destroy();
   }
+
+  function test_WebView_save_and_restore_error_page_data() {
+    return get_restore_types();
+  }
+
+  // Test that restoring the state of a navigation that had triggered an error
+  // triggers the error again (see https://launchpad.net/bugs/1423531).
+  function test_WebView_save_and_restore_error_page(data) {
+    var url = "http://invalid/";
+    webView.url = url;
+    verify(webView.waitForLoadCommitted(),
+           "Timed out waiting for error page");
+
+    var state = webView.currentState;
+    verify(state.length > 0);
+
+    var restored = webViewComponent.createObject(
+        webView, {"restoreType": data.restoreType, "restoreState": state});
+    verify(restored !== null);
+
+    var expectedLoadEvents = [
+      { type: LoadEvent.TypeStarted, isError: false },
+      { type: LoadEvent.TypeFailed, isError: false },
+      { type: LoadEvent.TypeCommitted, isError: true }
+    ];
+    function _loadEvent(event) {
+      var expected = expectedLoadEvents[0];
+      compare(event.type, expected.type);
+      compare(event.url, url);
+      compare(event.isError, expected.isError);
+      expectedLoadEvents.shift();
+    }
+    restored.loadEvent.connect(_loadEvent);
+
+    tryCompare(restored, "url", url);
+    restored.waitFor(function() {
+        return (expectedLoadEvents.length === 0);
+    });
+    restored.destroy();
+  }
 }