Extract MockBrowsingDataRemover to separate file to make it possible to use it

chrome/browser/browsing_data/browsing_data_remover_mock.cc

+// Copyright 2017 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/browsing_data/browsing_data_remover_mock.h"
+
+#include "content/public/browser/browsing_data_filter_builder.h"
+
+MockBrowsingDataRemover::MockBrowsingDataRemover(
+    content::BrowserContext* context)
+    : BrowsingDataRemoverImpl(context) {}
+
+MockBrowsingDataRemover::~MockBrowsingDataRemover() {
+  DCHECK(!expected_calls_.size()) << "Expectations were set but not verified.";
+}
+
+void MockBrowsingDataRemover::RemoveInternal(
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
+    int remove_mask,
+    int origin_type_mask,
+    std::unique_ptr<content::BrowsingDataFilterBuilder> filter_builder,
+    BrowsingDataRemover::Observer* observer) {
+  actual_calls_.emplace_back(delete_begin, delete_end, remove_mask,
+                             origin_type_mask, std::move(filter_builder),
+                             true /* should_compare_filter */);
+
+  // |observer| is not recorded in |actual_calls_| to be compared with
+  // expectations, because it's created internally in ClearSiteData() and
+  // it's unknown to this. However, it is tested implicitly, because we use
+  // it for the completion callback, so an incorrect |observer| will fail
+  // the test by waiting for the callback forever.
+  DCHECK(observer);
+  observer->OnBrowsingDataRemoverDone();
+}
+
+void MockBrowsingDataRemover::ExpectCall(
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
+    int remove_mask,
+    int origin_type_mask,
+    std::unique_ptr<content::BrowsingDataFilterBuilder> filter_builder) {
+  expected_calls_.emplace_back(delete_begin, delete_end, remove_mask,
+                               origin_type_mask, std::move(filter_builder),
+                               true /* should_compare_filter */);
+}
+
+void MockBrowsingDataRemover::ExpectCallDontCareAboutFilterBuilder(
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
+    int remove_mask,
+    int origin_type_mask) {
+  expected_calls_.emplace_back(
+      delete_begin, delete_end, remove_mask, origin_type_mask,
+      std::unique_ptr<content::BrowsingDataFilterBuilder>(),
+      false /* should_compare_filter */);
+}
+
+void MockBrowsingDataRemover::VerifyAndClearExpectations() {
+  EXPECT_EQ(expected_calls_, actual_calls_);
+  expected_calls_.clear();
+  actual_calls_.clear();
+}
+
+MockBrowsingDataRemover::CallParameters::CallParameters(
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
+    int remove_mask,
+    int origin_type_mask,
+    std::unique_ptr<content::BrowsingDataFilterBuilder> filter_builder,
+    bool should_compare_filter)
+    : delete_begin_(delete_begin),
+      delete_end_(delete_end),
+      remove_mask_(remove_mask),
+      origin_type_mask_(origin_type_mask),
+      filter_builder_(std::move(filter_builder)),
+      should_compare_filter_(should_compare_filter) {}
+MockBrowsingDataRemover::CallParameters::~CallParameters() {}
+
+bool MockBrowsingDataRemover::CallParameters::operator==(
+    const CallParameters& other) const {
+  const CallParameters& a = *this;
+  const CallParameters& b = other;
+
+  if (a.delete_begin_ != b.delete_begin_ || a.delete_end_ != b.delete_end_ ||
+      a.remove_mask_ != b.remove_mask_ ||
+      a.origin_type_mask_ != b.origin_type_mask_) {
+    return false;
+  }
+
+  if (!a.should_compare_filter_ || !b.should_compare_filter_)
+    return true;
+  return *a.filter_builder_ == *b.filter_builder_;
+}