Move ContentHashWaiter to test utils

Class ContentHashWaiter is declared in content_hash_fetcher_unittest.cc
but can also used in other tests, so it makes sense to move it to
test_utils.h under content_verifier directory.

Bug: 796395
Change-Id: I238a77018efa730153ede75a659b846d2a181103
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1847296
Commit-Queue: Oleg Davydov <burunduk@chromium.org>
Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704113}

extensions/browser/content_hash_fetcher_unittest.cc

@@ -12,14 +12,11 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
-#include "base/run_loop.h"
-#include "base/task/post_task.h"
 #include "base/version.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/browser_task_environment.h"
 #include "extensions/browser/content_hash_fetcher.h"
 #include "extensions/browser/content_verifier/test_utils.h"
-#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/browser/extensions_test.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_paths.h"
@@ -35,63 +32,6 @@
 
 namespace extensions {
 
-// Used to hold the result of a callback from the ContentHashFetcher.
-struct ContentHashFetcherResult {
-  std::string extension_id;
-  bool success;
-  bool was_cancelled;
-  std::set<base::FilePath> mismatch_paths;
-};
-
-// Allows waiting for the callback from a ContentHash, returning the
-// data that was passed to that callback.
-class ContentHashWaiter {
- public:
-  ContentHashWaiter()
-      : reply_task_runner_(base::SequencedTaskRunnerHandle::Get()) {}
-
-  std::unique_ptr<ContentHashFetcherResult> CreateAndWaitForCallback(
-      ContentHash::FetchKey key) {
-    GetExtensionFileTaskRunner()->PostTask(
-        FROM_HERE, base::BindOnce(&ContentHashWaiter::CreateContentHash,
-                                  base::Unretained(this), std::move(key)));
-    run_loop_.Run();
-    DCHECK(result_);
-    return std::move(result_);
-  }
-
- private:
-  void CreatedCallback(scoped_refptr<ContentHash> content_hash,
-                       bool was_cancelled) {
-    if (!reply_task_runner_->RunsTasksInCurrentSequence()) {
-      reply_task_runner_->PostTask(
-          FROM_HERE,
-          base::BindOnce(&ContentHashWaiter::CreatedCallback,
-                         base::Unretained(this), content_hash, was_cancelled));
-      return;
-    }
-
-    result_ = std::make_unique<ContentHashFetcherResult>();
-    result_->extension_id = content_hash->extension_id();
-    result_->success = content_hash->succeeded();
-    result_->was_cancelled = was_cancelled;
-    result_->mismatch_paths = content_hash->hash_mismatch_unix_paths();
-
-    run_loop_.QuitWhenIdle();
-  }
-
-  void CreateContentHash(ContentHash::FetchKey key) {
-    ContentHash::Create(std::move(key), ContentHash::IsCancelledCallback(),
-                        base::BindOnce(&ContentHashWaiter::CreatedCallback,
-                                       base::Unretained(this)));
-  }
-
-  scoped_refptr<base::SequencedTaskRunner> reply_task_runner_;
-  base::RunLoop run_loop_;
-  std::unique_ptr<ContentHashFetcherResult> result_;
-  DISALLOW_COPY_AND_ASSIGN(ContentHashWaiter);
-};
-
 // Installs and tests various functionality of an extension loaded without
 // verified_contents.json file.
 class ContentHashFetcherTest : public ExtensionsTest {
@@ -126,7 +66,7 @@ class ContentHashFetcherTest : public ExtensionsTest {
     return true;
   }
 
-  std::unique_ptr<ContentHashFetcherResult> DoHashFetch() {
+  std::unique_ptr<ContentHashResult> DoHashFetch() {
     if (!extension_.get() || !delegate_.get()) {
       ADD_FAILURE() << "No valid extension_ or delegate_, "
                        "did you forget to call LoadTestExtension()?";
@@ -138,7 +78,7 @@ class ContentHashFetcherTest : public ExtensionsTest {
     network::mojom::URLLoaderFactoryPtrInfo url_loader_factory_ptr_info =
         url_loader_factory_ptr.PassInterface();
 
-    std::unique_ptr<ContentHashFetcherResult> result =
+    std::unique_ptr<ContentHashResult> result =
         ContentHashWaiter().CreateAndWaitForCallback(ContentHash::FetchKey(
             extension_->id(), extension_->path(), extension_->version(),
             std::move(url_loader_factory_ptr_info), fetch_url_,
@@ -226,7 +166,7 @@ TEST_F(ContentHashFetcherTest, MissingVerifiedContents) {
   RegisterInterception(fetch_url(), GetResourcePath("verified_contents.json"));
 
   // Make sure the fetch was successful.
-  std::unique_ptr<ContentHashFetcherResult> result = DoHashFetch();
+  std::unique_ptr<ContentHashResult> result = DoHashFetch();
   ASSERT_TRUE(result.get());
   EXPECT_TRUE(result->success);
   EXPECT_FALSE(result->was_cancelled);
@@ -249,7 +189,7 @@ TEST_F(ContentHashFetcherTest, FetchInvalidVerifiedContents) {
   RegisterInterception(fetch_url(),
                        GetResourcePath("invalid_verified_contents.json"));
 
-  std::unique_ptr<ContentHashFetcherResult> result = DoHashFetch();
+  std::unique_ptr<ContentHashResult> result = DoHashFetch();
   ASSERT_TRUE(result.get());
   EXPECT_FALSE(result->success);
   EXPECT_FALSE(result->was_cancelled);
@@ -271,7 +211,7 @@ TEST_F(ContentHashFetcherTest, Fetch404VerifiedContents) {
   RegisterInterceptionWithFailure(fetch_url(), net::HTTP_NOT_FOUND);
 
   // Make sure the fetch was *not* successful.
-  std::unique_ptr<ContentHashFetcherResult> result = DoHashFetch();
+  std::unique_ptr<ContentHashResult> result = DoHashFetch();
   ASSERT_TRUE(result.get());
   EXPECT_FALSE(result->success);
   EXPECT_FALSE(result->was_cancelled);
@@ -296,7 +236,7 @@ TEST_F(ContentHashFetcherTest, MissingVerifiedContentsAndCorrupt) {
   RegisterInterception(fetch_url(), GetResourcePath("verified_contents.json"));
 
   // Make sure the fetch was *not* successful.
-  std::unique_ptr<ContentHashFetcherResult> result = DoHashFetch();
+  std::unique_ptr<ContentHashResult> result = DoHashFetch();
   ASSERT_NE(nullptr, result.get());
   EXPECT_TRUE(result->success);
   EXPECT_FALSE(result->was_cancelled);

extensions/browser/content_verifier/test_utils.cc

@@ -7,7 +7,9 @@
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/post_task.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "content/public/browser/browser_task_traits.h"
+#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/file_util.h"
@@ -201,6 +203,57 @@ void VerifierObserver::OnFetchComplete(const ExtensionId& extension_id,
     loop_runner_->Quit();
 }
 
+// ContentHashResult ----------------------------------------------------------
+ContentHashResult::ContentHashResult(
+    const ExtensionId& extension_id,
+    bool success,
+    bool was_cancelled,
+    const std::set<base::FilePath> mismatch_paths)
+    : extension_id(extension_id),
+      success(success),
+      was_cancelled(was_cancelled),
+      mismatch_paths(mismatch_paths) {}
+ContentHashResult::~ContentHashResult() = default;
+
+// ContentHashWaiter ----------------------------------------------------------
+ContentHashWaiter::ContentHashWaiter()
+    : reply_task_runner_(base::SequencedTaskRunnerHandle::Get()) {}
+ContentHashWaiter::~ContentHashWaiter() = default;
+
+std::unique_ptr<ContentHashResult> ContentHashWaiter::CreateAndWaitForCallback(
+    ContentHash::FetchKey key) {
+  GetExtensionFileTaskRunner()->PostTask(
+      FROM_HERE, base::BindOnce(&ContentHashWaiter::CreateContentHash,
+                                base::Unretained(this), std::move(key)));
+  run_loop_.Run();
+  DCHECK(result_);
+  return std::move(result_);
+}
+
+void ContentHashWaiter::CreatedCallback(scoped_refptr<ContentHash> content_hash,
+                                        bool was_cancelled) {
+  if (!reply_task_runner_->RunsTasksInCurrentSequence()) {
+    reply_task_runner_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&ContentHashWaiter::CreatedCallback,
+                       base::Unretained(this), content_hash, was_cancelled));
+    return;
+  }
+
+  DCHECK(content_hash);
+  result_ = std::make_unique<ContentHashResult>(
+      content_hash->extension_id(), content_hash->succeeded(), was_cancelled,
+      content_hash->hash_mismatch_unix_paths());
+
+  run_loop_.QuitWhenIdle();
+}
+
+void ContentHashWaiter::CreateContentHash(ContentHash::FetchKey key) {
+  ContentHash::Create(std::move(key), ContentHash::IsCancelledCallback(),
+                      base::BindOnce(&ContentHashWaiter::CreatedCallback,
+                                     base::Unretained(this)));
+}
+
 namespace content_verifier_test_utils {
 
 scoped_refptr<Extension> UnzipToDirAndLoadExtension(

extensions/browser/content_verifier/test_utils.h

@@ -8,9 +8,11 @@
 #include "base/files/file_path.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
+#include "base/sequenced_task_runner.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/content_verifier.h"
+#include "extensions/browser/content_verifier/content_hash.h"
 #include "extensions/browser/content_verifier_delegate.h"
 #include "extensions/browser/content_verify_job.h"
 #include "extensions/common/extension_id.h"
@@ -152,6 +154,43 @@ class VerifierObserver : public ContentVerifier::TestObserver {
   DISALLOW_COPY_AND_ASSIGN(VerifierObserver);
 };
 
+// Used to hold the result of a callback from the ContentHash creation.
+struct ContentHashResult {
+  ContentHashResult(const ExtensionId& extension_id,
+                    bool success,
+                    bool was_cancelled,
+                    const std::set<base::FilePath> mismatch_paths);
+  ~ContentHashResult();
+
+  ExtensionId extension_id;
+  bool success;
+  bool was_cancelled;
+  std::set<base::FilePath> mismatch_paths;
+};
+
+// Allows waiting for the callback from a ContentHash, returning the
+// data that was passed to that callback.
+class ContentHashWaiter {
+ public:
+  ContentHashWaiter();
+  ~ContentHashWaiter();
+
+  std::unique_ptr<ContentHashResult> CreateAndWaitForCallback(
+      ContentHash::FetchKey key);
+
+ private:
+  void CreatedCallback(scoped_refptr<ContentHash> content_hash,
+                       bool was_cancelled);
+
+  void CreateContentHash(ContentHash::FetchKey key);
+
+  scoped_refptr<base::SequencedTaskRunner> reply_task_runner_;
+  base::RunLoop run_loop_;
+  std::unique_ptr<ContentHashResult> result_;
+
+  DISALLOW_COPY_AND_ASSIGN(ContentHashWaiter);
+};
+
 namespace content_verifier_test_utils {
 
 // Unzips the extension source from |extension_zip| into |unzip_dir|