Merge codereview.chromium.org/630243002 onto 2171 branch

extensions/browser/content_verify_job.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 "extensions/browser/content_verify_job.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "base/timer/elapsed_timer.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/content_hash_reader.h"
 
 namespace extensions {
 
 namespace {
 
 ContentVerifyJob::TestDelegate* g_test_delegate = NULL;
+ContentVerifyJob::TestObserver* g_test_observer = NULL;
 
 class ScopedElapsedTimer {
  public:
   ScopedElapsedTimer(base::TimeDelta* total) : total_(total) { DCHECK(total_); }
 
   ~ScopedElapsedTimer() { *total_ += timer.Elapsed(); }
 
  private:
   // Some total amount of time we should add our elapsed time to at
   // destruction.
@@ skipping 20 matching lines @@
   thread_checker_.DetachFromThread();
 }
 
 ContentVerifyJob::~ContentVerifyJob() {
   UMA_HISTOGRAM_COUNTS("ExtensionContentVerifyJob.TimeSpentUS",
                        time_spent_.InMicroseconds());
 }
 
 void ContentVerifyJob::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (g_test_observer)
+    g_test_observer->JobStarted(hash_reader_->extension_id(),
+                                hash_reader_->relative_path());
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&ContentHashReader::Init, hash_reader_),
       base::Bind(&ContentVerifyJob::OnHashesReady, this));
 }
 
 void ContentVerifyJob::BytesRead(int count, const char* data) {
   ScopedElapsedTimer timer(&time_spent_);
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 50 matching lines @@
     FailureReason reason =
         g_test_delegate->DoneReading(hash_reader_->extension_id());
     if (reason != NONE) {
       DispatchFailureCallback(reason);
       return;
     }
   }
   done_reading_ = true;
   if (hashes_ready_ && !FinishBlock())
     DispatchFailureCallback(HASH_MISMATCH);
+
+  if (!failed_ && g_test_observer)
+    g_test_observer->JobFinished(
+        hash_reader_->extension_id(), hash_reader_->relative_path(), failed_);
 }
 
 bool ContentVerifyJob::FinishBlock() {
   if (current_hash_byte_count_ <= 0)
     return true;
   std::string final(crypto::kSHA256Length, 0);
   current_hash_->Finish(string_as_array(&final), final.size());
   current_hash_.reset();
   current_hash_byte_count_ = 0;
 
@@ skipping 32 matching lines @@
     if (!FinishBlock())
       DispatchFailureCallback(HASH_MISMATCH);
   }
 }
 
 // static
 void ContentVerifyJob::SetDelegateForTests(TestDelegate* delegate) {
   g_test_delegate = delegate;
 }
 
+// static
+void ContentVerifyJob::SetObserverForTests(TestObserver* observer) {
+  g_test_observer = observer;
+}
+
 void ContentVerifyJob::DispatchFailureCallback(FailureReason reason) {
   DCHECK(!failed_);
   failed_ = true;
   if (!failure_callback_.is_null()) {
     VLOG(1) << "job failed for " << hash_reader_->extension_id() << " "
             << hash_reader_->relative_path().MaybeAsASCII()
             << " reason:" << reason;
     failure_callback_.Run(reason);
     failure_callback_.Reset();
   }
+  if (g_test_observer)
+    g_test_observer->JobFinished(
+        hash_reader_->extension_id(), hash_reader_->relative_path(), failed_);
 }
 
 }  // namespace extensions