[Offline pages] Add navigation error handling to background loader.

chrome/browser/android/offline_pages/background_loader_offliner_unittest.cc

 // Copyright 2016 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/android/offline_pages/background_loader_offliner.h"
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/offline_pages/content/background_loader/background_loader_contents_stub.h"
 #include "components/offline_pages/core/background/offliner.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/stub_offline_page_model.h"
 #include "components/prefs/pref_service.h"
+#include "content/public/browser/navigation_handle.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
+#include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
 const int64_t kRequestId = 7;
 const GURL kHttpUrl("http://www.tunafish.com");
 const GURL kFileUrl("file://salmon.png");
 const ClientId kClientId("AsyncLoading", "88");
@@ skipping 47 matching lines @@
 // This is a temporary solution to test core BackgroundLoaderOffliner
 // functionality until we straighten out assumptions made by RequestCoordinator
 // so that the ResetState method is no longer needed.
 class TestBackgroundLoaderOffliner : public BackgroundLoaderOffliner {
  public:
   explicit TestBackgroundLoaderOffliner(
       content::BrowserContext* browser_context,
       const OfflinerPolicy* policy,
       OfflinePageModel* offline_page_model);
   ~TestBackgroundLoaderOffliner() override;
-  content::WebContentsTester* web_contents() {
+  content::WebContentsTester* web_contents_tester() {
     return content::WebContentsTester::For(stub_->web_contents());
   }
 
+  content::WebContents* web_contents() { return stub_->web_contents(); }
+
   bool is_loading() { return stub_->is_loading(); }
 
  protected:
   void ResetState() override;
 
  private:
   background_loader::BackgroundLoaderContentsStub* stub_;
 };
 
 TestBackgroundLoaderOffliner::TestBackgroundLoaderOffliner(
@@ skipping 26 matching lines @@
   Profile* profile() { return &profile_; }
   bool completion_callback_called() { return completion_callback_called_; }
   Offliner::RequestStatus request_status() { return request_status_; }
   bool SaveInProgress() const { return model_->mock_saving(); }
   MockOfflinePageModel* model() const { return model_; }
   const base::HistogramTester& histograms() const { return histogram_tester_; }
 
   void CompleteLoading() {
     // For some reason, setting loading to True will call DidStopLoading
     // on the observers.
-    offliner()->web_contents()->TestSetIsLoading(true);
+    offliner()->web_contents_tester()->TestSetIsLoading(true);
   }
 
  private:
   void OnCompletion(const SavePageRequest& request,
                     Offliner::RequestStatus status);
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   std::unique_ptr<TestBackgroundLoaderOffliner> offliner_;
   MockOfflinePageModel* model_;
   bool completion_callback_called_;
@@ skipping 182 matching lines @@
   base::Time creation_time = base::Time::Now();
   SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time,
                           kUserRequested);
   EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
   offliner()->WebContentsDestroyed();
 
   EXPECT_TRUE(completion_callback_called());
   EXPECT_EQ(Offliner::RequestStatus::LOADING_FAILED, request_status());
 }
 
+TEST_F(BackgroundLoaderOfflinerTest, FailsOnErrorPage) {
+  base::Time creation_time = base::Time::Now();
+  SavePageRequest request(kRequestId, kHttpUrl, kClientId, creation_time,
+                          kUserRequested);
+  EXPECT_TRUE(offliner()->LoadAndSave(request, callback()));
+
+  // Create handle with net error code.
+  // Called after calling LoadAndSave so we have web_contents to work with.
+  std::unique_ptr<content::NavigationHandle> handle(
+      content::NavigationHandle::CreateNavigationHandleForTesting(
+          kHttpUrl, offliner()->web_contents()->GetMainFrame(), true,
+          net::Error::ERR_NAME_NOT_RESOLVED));
+  // Call DidFinishNavigation with handle that contains error.
+  offliner()->DidFinishNavigation(handle.get());
+  // NavigationHandle is always destroyed after finishing navigation.
+  handle.reset();
+  offliner()->DidStopLoading();
+  PumpLoop();
+
+  EXPECT_TRUE(completion_callback_called());
+  EXPECT_EQ(Offliner::RequestStatus::LOADING_FAILED_NO_RETRY, request_status());
+}
+
 }  // namespace offline_pages