Adds unit tests for Offliner SavePage implementation.

chrome/browser/android/offline_pages/prerendering_offliner.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/prerendering_offliner.h"
 
 #include "base/bind.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "components/offline_pages/background/save_page_request.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 83 matching lines @@
   completion_callback.Run(request, save_status);
 }
 
 bool PrerenderingOffliner::LoadAndSave(const SavePageRequest& request,
                                        const CompletionCallback& callback) {
   if (pending_request_) {
     DVLOG(1) << "Already have pending request";
     return false;
   }
 
-  if (!CanSavePage(request.url())) {
-    DVLOG(1) << "Not able to save page";
+  if (!GetOrCreateLoader()->CanPrerender()) {
+    DVLOG(1) << "Prerendering not allowed/configured";
     return false;
   }
 
+  if (!OfflinePageModel::CanSavePage(request.url())) {
+    DVLOG(1) << "Not able to save page for requested url: " << request.url();
+    return false;
+  }
+
   // Track pending request for callback handling.
   pending_request_ = &request;
 
   // Kick off load page attempt.
   bool accepted = GetOrCreateLoader()->LoadPage(
       request.url(),
       base::Bind(&PrerenderingOffliner::OnLoadPageDone,
                  weak_ptr_factory_.GetWeakPtr(), request, callback));
   if (!accepted)
     pending_request_ = nullptr;
 
   return accepted;
 }
 
 void PrerenderingOffliner::Cancel() {
   if (pending_request_) {
     pending_request_ = nullptr;
     GetOrCreateLoader()->StopLoading();
     // TODO(dougarnett): Consider ability to cancel SavePage request.
   }
 }
 
 void PrerenderingOffliner::SetLoaderForTesting(
     std::unique_ptr<PrerenderingLoader> loader) {
   DCHECK(!loader_);
   loader_ = std::move(loader);
 }
 
-bool PrerenderingOffliner::CanSavePage(const GURL& url) {
-  if (!offline_page_model_) {
-    // Assume we can save if no OfflinePageModel (for unit tests).
-    // TODO(dougarnett): Make OfflinePageModel::CanSavePage() mockable for test.
-    return true;
-  }
-  return offline_page_model_->CanSavePage(url);
-}
-
 void PrerenderingOffliner::SavePage(
     const GURL& url,
     const ClientId& client_id,
     std::unique_ptr<OfflinePageArchiver> archiver,
     const SavePageCallback& callback) {
   DCHECK(offline_page_model_);
   offline_page_model_->SavePage(url, client_id, std::move(archiver), callback);
 }
 
 PrerenderingLoader* PrerenderingOffliner::GetOrCreateLoader() {
   if (!loader_) {
     loader_.reset(new PrerenderingLoader(browser_context_));
   }
   return loader_.get();
 }
 
 }  // namespace offline_pages