Fix content verification code for undreadable and deleted files.

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/bind_helpers.h"
 #include "base/callback_helpers.h"
@@ skipping 108 matching lines @@
 
 // Helper for forcing ContentVerifyJob's to return an error.
 class JobDelegate : public ContentVerifyJob::TestDelegate {
  public:
   JobDelegate()
       : fail_next_read_(false),
         fail_next_done_(false),
         bytes_read_failed_(0),
         done_reading_failed_(0) {}
 
-  virtual ~JobDelegate() {}
+  ~JobDelegate() override {}
 
   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_; }
 
@@ skipping 42 matching lines @@
   // Wait to see expected jobs. Returns true when we've seen all expected jobs
   // finish, or false if there was an error or timeout.
   bool WaitForExpectedJobs();
 
   // ContentVerifyJob::TestObserver interface
   void JobStarted(const std::string& extension_id,
                   const base::FilePath& relative_path) override;
 
   void JobFinished(const std::string& extension_id,
                    const base::FilePath& relative_path,
-                   bool failed) override;
+                   ContentVerifyJob::FailureReason failure_reason) override;
 
  private:
   struct ExpectedResult {
    public:
     std::string extension_id;
     base::FilePath path;
     Result result;
 
     ExpectedResult(const std::string& extension_id, const base::FilePath& path,
                    Result result) {
@@ skipping 31 matching lines @@
   }
   return expectations_.empty();
 }
 
 void JobObserver::JobStarted(const std::string& extension_id,
                              const base::FilePath& relative_path) {
 }
 
 void JobObserver::JobFinished(const std::string& extension_id,
                               const base::FilePath& relative_path,
-                              bool failed) {
+                              ContentVerifyJob::FailureReason failure_reason) {
   if (!content::BrowserThread::CurrentlyOn(creation_thread_)) {
     content::BrowserThread::PostTask(
         creation_thread_, FROM_HERE,
         base::Bind(&JobObserver::JobFinished, base::Unretained(this),
-                   extension_id, relative_path, failed));
+                   extension_id, relative_path, failure_reason));
     return;
   }
-  Result result = failed ? Result::FAILURE : Result::SUCCESS;
+  Result result = failure_reason == ContentVerifyJob::NONE ? Result::SUCCESS
+                                                           : Result::SUCCESS;

[Devlin, 2017/03/29 15:51:56]

Result::FAILURE?

[lazyboy, 2017/03/29 17:12:50]

Done, thanks.

   bool found = false;
   for (std::list<ExpectedResult>::iterator i = expectations_.begin();
        i != expectations_.end(); ++i) {
     if (i->extension_id == extension_id && i->path == relative_path &&
         i->result == result) {
       found = true;
       expectations_.erase(i);
       break;
     }
   }
   if (found) {
     if (expectations_.empty() && loop_runner_.get())
       loop_runner_->Quit();
   } else {
     LOG(WARNING) << "Ignoring unexpected JobFinished " << extension_id << "/"
-                 << relative_path.value() << " failed:" << failed;
+                 << relative_path.value()
+                 << " failure_reason:" << failure_reason;
   }
 }
 
 class VerifierObserver : public ContentVerifier::TestObserver {
  public:
   VerifierObserver();
   virtual ~VerifierObserver();
 
   const std::set<std::string>& completed_fetches() {
     return completed_fetches_;
@@ skipping 548 matching lines @@
   // Assert that the first reinstall action happened with a delay of 0, and
   // then kept growing each additional time.
   ASSERT_EQ(iterations, calls.size());
   EXPECT_EQ(base::TimeDelta(), delay_tracker.calls()[0]);
   for (size_t i = 1; i < delay_tracker.calls().size(); i++) {
     EXPECT_LT(calls[i - 1], calls[i]);
   }
 }
 
 }  // namespace extensions