Improve ContentVerifierTest.Fail* tests

chrome/browser/extensions/content_verifier_browsertest.cc

 // Copyright 2014 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 <list>
 #include <set>
 #include <string>
 
 #include "base/scoped_observer.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
@@ skipping 38 matching lines @@
  private:
   ExtensionId awaited_id_;
   std::set<ExtensionId> observed_;
   scoped_refptr<content::MessageLoopRunner> loop_runner_;
   ScopedObserver<ExtensionRegistry, UnloadObserver> observer_;
 };
 
 // Helper for forcing ContentVerifyJob's to return an error.
 class JobDelegate : public ContentVerifyJob::TestDelegate {
  public:
-  JobDelegate() : fail_next_read_(false), fail_next_done_(false) {}
+  JobDelegate()
+      : fail_next_read_(false),
+        fail_next_done_(false),
+        bytes_read_failed_(0),
+        done_reading_failed_(0) {}
 
   virtual ~JobDelegate() {}
 
   void set_id(const ExtensionId& id) { id_ = id; }
   void fail_next_read() { fail_next_read_ = true; }
   void fail_next_done() { fail_next_done_ = true; }
 
+  // Return the number of BytesRead/DoneReading calls we actually failed,
+  // respectively.
+  int bytes_read_failed() { return bytes_read_failed_; }
+  int done_reading_failed() { return done_reading_failed_; }
+
   ContentVerifyJob::FailureReason BytesRead(const ExtensionId& id,
                                             int count,
                                             const char* data) override {
     if (id == id_ && fail_next_read_) {
       fail_next_read_ = false;
+      bytes_read_failed_++;
       return ContentVerifyJob::HASH_MISMATCH;
     }
     return ContentVerifyJob::NONE;
   }
 
   ContentVerifyJob::FailureReason DoneReading(const ExtensionId& id) override {
     if (id == id_ && fail_next_done_) {
       fail_next_done_ = false;
+      done_reading_failed_++;
       return ContentVerifyJob::HASH_MISMATCH;
     }
     return ContentVerifyJob::NONE;
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(JobDelegate);
-
   ExtensionId id_;
   bool fail_next_read_;
   bool fail_next_done_;
+  int bytes_read_failed_;
+  int done_reading_failed_;
+
+  DISALLOW_COPY_AND_ASSIGN(JobDelegate);
 };
 
 class JobObserver : public ContentVerifyJob::TestObserver {
  public:
   JobObserver();
   virtual ~JobObserver();
 
   enum class Result { SUCCESS, FAILURE };
 
   // Call this to add an expected job result.
@@ skipping 154 matching lines @@
   }
 
   void TearDownOnMainThread() override {
     ContentVerifier::SetObserverForTests(NULL);
     ContentVerifyJob::SetDelegateForTests(NULL);
     ContentVerifyJob::SetObserverForTests(NULL);
     ExtensionBrowserTest::TearDownOnMainThread();
   }
 
   virtual void OpenPageAndWaitForUnload() {
+    ContentVerifyJob::SetDelegateForTests(&delegate_);
+    std::string id = "npnbmohejbjohgpjnmjagbafnjhkmgko";
+    delegate_.set_id(id);
     unload_observer_.reset(
         new UnloadObserver(ExtensionRegistry::Get(profile())));
     const Extension* extension = InstallExtensionFromWebstore(
         test_data_dir_.AppendASCII("content_verifier/v1.crx"), 1);
     ASSERT_TRUE(extension);
-    id_ = extension->id();
+    ASSERT_EQ(id, extension->id());
     page_url_ = extension->GetResourceURL("page.html");
-    delegate_.set_id(id_);
-    ContentVerifyJob::SetDelegateForTests(&delegate_);
 
     // This call passes false for |check_navigation_success|, because checking
     // for navigation success needs the WebContents to still exist after the
     // navigation, whereas this navigation triggers an unload which destroys
     // the WebContents.
     AddTabAtIndexToBrowser(browser(), 1, page_url_, ui::PAGE_TRANSITION_LINK,
                            false);
 
-    unload_observer_->WaitForUnload(id_);
+    unload_observer_->WaitForUnload(id);
     ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
-    int reasons = prefs->GetDisableReasons(id_);
+    int reasons = prefs->GetDisableReasons(id);
     EXPECT_TRUE(reasons & Extension::DISABLE_CORRUPTED);
 
     // This needs to happen before the ExtensionRegistry gets deleted, which
     // happens before TearDownOnMainThread is called.
     unload_observer_.reset();
   }
 
  protected:
   JobDelegate delegate_;
   scoped_ptr<UnloadObserver> unload_observer_;
-  ExtensionId id_;
   GURL page_url_;
 };
 
 IN_PROC_BROWSER_TEST_F(ContentVerifierTest, FailOnRead) {
+  EXPECT_EQ(0, delegate_.bytes_read_failed());
   delegate_.fail_next_read();
   OpenPageAndWaitForUnload();
+  EXPECT_EQ(1, delegate_.bytes_read_failed());
 }
 
 IN_PROC_BROWSER_TEST_F(ContentVerifierTest, FailOnDone) {
+  EXPECT_EQ(0, delegate_.done_reading_failed());
   delegate_.fail_next_done();
   OpenPageAndWaitForUnload();
+  EXPECT_EQ(1, delegate_.done_reading_failed());
 }
 
 IN_PROC_BROWSER_TEST_F(ContentVerifierTest, DotSlashPaths) {
   JobObserver job_observer;
   ContentVerifyJob::SetObserverForTests(&job_observer);
   std::string id = "hoipipabpcoomfapcecilckodldhmpgl";
 
   job_observer.ExpectJobResult(
       id, base::FilePath(FILE_PATH_LITERAL("background.js")),
       JobObserver::Result::SUCCESS);
@@ skipping 82 matching lines @@
   job_observer.ExpectJobResult(id,
                                base::FilePath(FILE_PATH_LITERAL("script.js")),
                                JobObserver::Result::FAILURE);
   EnableExtension(id);
   EXPECT_TRUE(job_observer.WaitForExpectedJobs());
 
   ContentVerifyJob::SetObserverForTests(NULL);
 }
 
 }  // namespace extensions