[OfflinePages] Improve visiblity/handling of "Loading not started" case

chrome/browser/android/offline_pages/prerendering_loader_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/prerendering_loader.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.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 "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
 // Adapter that intercepts prerender stack calls for testing.
 class TestAdapter : public PrerenderAdapter {
  public:
   explicit TestAdapter(PrerenderAdapter::Observer* observer)
       : PrerenderAdapter(observer),
         active_(false),
-        disabled_(false),
         fail_start_(false),
         observer_(observer),
         final_status_(prerender::FINAL_STATUS_MAX) {}
   ~TestAdapter() override {}
 
   // PrerenderAdapter implementation.
-  bool CanPrerender() const override;
   bool StartPrerender(
       content::BrowserContext* browser_context,
       const GURL& url,
       content::SessionStorageNamespace* session_storage_namespace,
       const gfx::Size& size) override;
   content::WebContents* GetWebContents() const override;
   prerender::FinalStatus GetFinalStatus() const override;
   bool IsActive() const override;
   void DestroyActive() override;
 
-  // Sets prerendering to be disabled. This will cause the CanPrerender()
-  // to return false.
-  void Disable();
-
   // Sets prerendering to fail start prerender requests.
   void FailStart();
 
   // Configures mocked prerendering details.
   void Configure(content::WebContents* web_contents,
                  prerender::FinalStatus final_status);
 
   // Returns the observer for test access.
   PrerenderAdapter::Observer* GetObserver() const { return observer_; }
 
  private:
   bool active_;
-  bool disabled_;
   bool fail_start_;
   PrerenderAdapter::Observer* observer_;
   std::unique_ptr<content::WebContents> web_contents_;
   prerender::FinalStatus final_status_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAdapter);
 };
 
-void TestAdapter::Disable() {
-  disabled_ = true;
-}
-
 void TestAdapter::FailStart() {
   fail_start_ = true;
 }
 
 void TestAdapter::Configure(content::WebContents* web_contents,
                             prerender::FinalStatus final_status) {
   web_contents_ = base::WrapUnique(web_contents);
   final_status_ = final_status;
 }
 
-bool TestAdapter::CanPrerender() const {
-  return !disabled_;
-}
-
 bool TestAdapter::StartPrerender(
     content::BrowserContext* browser_context,
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   if (fail_start_)
     return false;
   active_ = true;
   return true;
 }
@@ skipping 62 matching lines @@
   callback_called_ = false;
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 void PrerenderingLoaderTest::OnLoadDone(Offliner::RequestStatus load_status,
                                         content::WebContents* web_contents) {
   callback_called_ = true;
   callback_load_status_ = load_status;
 }
 
-TEST_F(PrerenderingLoaderTest, CanPrerender) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  EXPECT_TRUE(loader()->CanPrerender());
-
-  test_adapter()->Disable();
-  EXPECT_FALSE(loader()->CanPrerender());
-}
-
 TEST_F(PrerenderingLoaderTest, StopLoadingWhenIdle) {
   EXPECT_TRUE(loader()->IsIdle());
   loader()->StopLoading();
   EXPECT_TRUE(loader()->IsIdle());
 }
 
 TEST_F(PrerenderingLoaderTest, LoadPageLoadSucceededFromDomContentLoaded) {
   test_adapter()->Configure(
       content::WebContentsTester::CreateTestWebContents(profile(), NULL),
       prerender::FINAL_STATUS_USED);
@@ skipping 194 matching lines @@
   EXPECT_FALSE(loader()->IsIdle());
   EXPECT_FALSE(loader()->IsLoaded());
 
   // Now try another load while first is still active.
   EXPECT_FALSE(loader()->LoadPage(
       gurl,
       base::Bind(&PrerenderingLoaderTest::OnLoadDone, base::Unretained(this))));
   EXPECT_FALSE(loader()->IsIdle());
 }
 
-TEST_F(PrerenderingLoaderTest, LoadPageNotAcceptedWhenPrerenderingDisabled) {
-  test_adapter()->Disable();
-  GURL gurl("http://testit.sea");
-  EXPECT_TRUE(loader()->IsIdle());
-  EXPECT_FALSE(loader()->LoadPage(
-      gurl,
-      base::Bind(&PrerenderingLoaderTest::OnLoadDone, base::Unretained(this))));
-  EXPECT_TRUE(loader()->IsIdle());
-}
-
 TEST_F(PrerenderingLoaderTest, LoadPageNotAcceptedWhenStartPrerenderFalse) {
   test_adapter()->FailStart();
   GURL gurl("http://testit.sea");
   EXPECT_TRUE(loader()->IsIdle());
   EXPECT_FALSE(loader()->LoadPage(
       gurl,
       base::Bind(&PrerenderingLoaderTest::OnLoadDone, base::Unretained(this))));
   EXPECT_TRUE(loader()->IsIdle());
 }
 
 }  // namespace offline_pages