Reduce BrowsingDataRemover's dependencies on Chrome

chrome/browser/browsing_data/browsing_data_remover.h

 // Copyright (c) 2012 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.
 
 #ifndef CHROME_BROWSER_BROWSING_DATA_BROWSING_DATA_REMOVER_H_
 #define CHROME_BROWSER_BROWSING_DATA_BROWSING_DATA_REMOVER_H_
 
 #include <stdint.h>
 
 #include <queue>
 #include <set>
 
 #include "base/callback_forward.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/synchronization/waitable_event_watcher.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_delegate.h"
 #include "chrome/common/features.h"
-#include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "ppapi/features/features.h"
 #include "storage/common/quota/quota_types.h"
 #include "url/gurl.h"
 
 class BrowsingDataFilterBuilder;
 class BrowsingDataFlashLSOHelper;
 class BrowsingDataRemoverFactory;
-class Profile;
 
 namespace content {
 class BrowserContext;
 class PluginDataRemover;
 class StoragePartition;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowsingDataRemover is responsible for removing data related to browsing:
 // visits in url database, downloads, cookies ...
 //
 //  USAGE:
 //
 //  0. Instantiation.
 //
 //       BrowsingDataRemover remover =
-//           BrowsingDataRemoverFactory::GetForBrowserContext(profile);
+//           BrowsingDataRemoverFactory::GetForBrowserContext(browser_context);
 //
 //  1. No observer.
 //
-//       remover->Remove(Unbounded(), REMOVE_COOKIES, ALL);
+//       remover->Remove(base::Time(), base::Time::Max(), REMOVE_COOKIES, ALL);
 //
 //  2. Using an observer to report when one's own removal task is finished.
 //
 //       class CookiesDeleter : public BrowsingDataRemover::Observer {
 //         CookiesDeleter() { remover->AddObserver(this); }
 //         ~CookiesDeleter() { remover->RemoveObserver(this); }
 //
 //         void DeleteCookies() {
-//           remover->RemoveAndReply(Unbounded(), REMOVE_COOKIES, ALL, this);
+//           remover->RemoveAndReply(base::Time(), base::Time::Max(),
+//                                   REMOVE_COOKIES, ALL, this);
 //         }
 //
 //         void OnBrowsingDataRemoverDone() {
 //           LOG(INFO) << "Cookies were deleted.";
 //         }
 //       }
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 class BrowsingDataRemover : public KeyedService {
@@ skipping 11 matching lines @@
     REMOVE_HISTORY = 1 << 6,
     REMOVE_INDEXEDDB = 1 << 7,
     REMOVE_LOCAL_STORAGE = 1 << 8,
     REMOVE_PLUGIN_DATA = 1 << 9,
     REMOVE_PASSWORDS = 1 << 10,
     REMOVE_WEBSQL = 1 << 11,
     REMOVE_CHANNEL_IDS = 1 << 12,
     REMOVE_MEDIA_LICENSES = 1 << 13,
     REMOVE_SERVICE_WORKERS = 1 << 14,
     REMOVE_SITE_USAGE_DATA = 1 << 15,
-    // REMOVE_NOCHECKS intentionally does not check if the Profile's prohibited
-    // from deleting history or downloads.
+    // REMOVE_NOCHECKS intentionally does not check if the browser context is
+    // prohibited from deleting history or downloads.
     REMOVE_NOCHECKS = 1 << 16,
     REMOVE_CACHE_STORAGE = 1 << 17,
 #if BUILDFLAG(ANDROID_JAVA_UI)
     REMOVE_WEBAPP_DATA = 1 << 18,
 #endif
     REMOVE_DURABLE_PERMISSION = 1 << 19,
 
     // The following flag is used only in tests. In normal usage, hosted app
     // data is controlled by the REMOVE_COOKIES flag, applied to the
     // protected-web origin.
@@ skipping 50 matching lines @@
   // A helper enum to report the deletion of cookies and/or cache. Do not
   // reorder the entries, as this enum is passed to UMA.
   enum CookieOrCacheDeletionChoice {
     NEITHER_COOKIES_NOR_CACHE,
     ONLY_COOKIES,
     ONLY_CACHE,
     BOTH_COOKIES_AND_CACHE,
     MAX_CHOICE_VALUE
   };
 
-  struct TimeRange {
-    TimeRange(base::Time begin, base::Time end) : begin(begin), end(end) {}
-    bool operator==(const TimeRange& other) const;
-
-    base::Time begin;
-    base::Time end;
-  };
-
   // Observer is notified when its own removal task is done.
   class Observer {
    public:
     // Called when a removal task is finished. Note that every removal task can
     // only have one observer attached to it, and only that one is called.
     virtual void OnBrowsingDataRemoverDone() = 0;
 
    protected:
     virtual ~Observer() {}
   };
@@ skipping 33 matching lines @@
     bool is_pending() const { return is_pending_; }
 
    private:
     void CompletionCallback();
 
     bool is_pending_;
     const base::Closure& forward_callback_;
     base::WeakPtrFactory<SubTask> weak_ptr_factory_;
   };
 
-  static TimeRange Unbounded();
-
-  static TimeRange Period(browsing_data::TimePeriod period);
-
   // Is the BrowsingDataRemover currently in the process of removing data?
   bool is_removing() { return is_removing_; }
 
   // Sets a CompletionInhibitor, which will be notified each time an instance is
   // about to complete a browsing data removal process, and will be able to
   // artificially delay the completion.
   // TODO(crbug.com/483528): Make this non-static.
   static void set_completion_inhibitor_for_testing(
       CompletionInhibitor* inhibitor) {
     completion_inhibitor_ = inhibitor;
   }
 
   // Called by the embedder to provide the delegate that will take care of
   // deleting embedder-specific data.
   void set_embedder_delegate(
       std::unique_ptr<BrowsingDataRemoverDelegate> embedder_delegate) {
     embedder_delegate_ = std::move(embedder_delegate);
   }
 
   BrowsingDataRemoverDelegate* get_embedder_delegate() const {
     return embedder_delegate_.get();
   }
 
   // Removes browsing data within the given |time_range|, with datatypes being
   // specified by |remove_mask| and origin types by |origin_type_mask|.
-  void Remove(const TimeRange& time_range,
+  void Remove(const base::Time& delete_begin,
+              const base::Time& delete_end,
               int remove_mask,
               int origin_type_mask);
 
   // A version of the above that in addition informs the |observer| when the
   // removal task is finished.
-  void RemoveAndReply(const TimeRange& time_range,
+  void RemoveAndReply(const base::Time& delete_begin,
+                      const base::Time& delete_end,
                       int remove_mask,
                       int origin_type_mask,
                       Observer* observer);
 
   // Like Remove(), but in case of URL-keyed only removes data whose URL match
   // |filter_builder| (e.g. are on certain origin or domain).
   // RemoveWithFilter() currently only works with FILTERABLE_DATATYPES.
   void RemoveWithFilter(
-      const TimeRange& time_range,
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
       int remove_mask,
       int origin_type_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder);
 
   // A version of the above that in addition informs the |observer| when the
   // removal task is finished.
   void RemoveWithFilterAndReply(
-      const TimeRange& time_range,
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
       int remove_mask,
       int origin_type_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
       Observer* observer);
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Used for testing.
   void OverrideStoragePartitionForTesting(
@@ skipping 14 matching lines @@
   int GetLastUsedOriginTypeMask();
 
  protected:
   // Use BrowsingDataRemoverFactory::GetForBrowserContext to get an instance of
   // this class. The constructor is protected so that the class is mockable.
   BrowsingDataRemover(content::BrowserContext* browser_context);
   ~BrowsingDataRemover() override;
 
   // A common reduction of all public Remove[WithFilter][AndReply] methods.
   virtual void RemoveInternal(
-      const TimeRange& time_range,
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
       int remove_mask,
       int origin_type_mask,
       std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
       Observer* observer);
 
  private:
   // Testing the private RemovalTask.
   FRIEND_TEST_ALL_PREFIXES(BrowsingDataRemoverTest, MultipleTasks);
 
   // The BrowsingDataRemover tests need to be able to access the implementation
   // of Remove(), as it exposes details that aren't yet available in the public
   // API. As soon as those details are exposed via new methods, this should be
   // removed.
   //
   // TODO(mkwst): See http://crbug.com/113621
   friend class BrowsingDataRemoverTest;
 
   friend class BrowsingDataRemoverFactory;
 
   // Represents a single removal task. Contains all parameters needed to execute
   // it and a pointer to the observer that added it.
   struct RemovalTask {
-    RemovalTask(const TimeRange& time_range,
+    RemovalTask(const base::Time& delete_begin,
+                const base::Time& delete_end,
                 int remove_mask,
                 int origin_type_mask,
                 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
                 Observer* observer);
     ~RemovalTask();
 
-    TimeRange time_range;
+    base::Time delete_begin;
+    base::Time delete_end;
     int remove_mask;
     int origin_type_mask;
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder;
     Observer* observer;
   };
 
   void Shutdown() override;
 
   // Setter for |is_removing_|; DCHECKs that we can only start removing if we're
   // not already removing, and vice-versa.
@@ skipping 17 matching lines @@
   void RunNextTask();
 
   // Removes the specified items related to browsing for a specific host. If the
   // provided |remove_url| is empty, data is removed for all origins; otherwise,
   // it is restricted by the origin filter origin (where implemented yet). The
   // |origin_type_mask| parameter defines the set of origins from which data
   // should be removed (protected, unprotected, or both).
   // TODO(ttr314): Remove "(where implemented yet)" constraint above once
   // crbug.com/113621 is done.
   // TODO(crbug.com/589586): Support all backends w/ origin filter.
-  void RemoveImpl(const TimeRange& time_range,
+  void RemoveImpl(const base::Time& delete_begin,
+                  const base::Time& delete_end,
                   int remove_mask,
                   const BrowsingDataFilterBuilder& filter_builder,
                   int origin_type_mask);
 
   // Notifies observers and transitions to the idle state.
   void Notify();
 
   // Checks if we are all done, and if so, calls Notify().
   void NotifyIfDone();
 
   // Returns true if we're all done.
   bool AllDone();
 
-  // Profile we're to remove from.
-  Profile* profile_;
+  // The browser context we're to remove from.
+  content::BrowserContext* browser_context_;
 
   // A delegate to delete the embedder-specific data.
   std::unique_ptr<BrowsingDataRemoverDelegate> embedder_delegate_;
 
   // Start time to delete from.
   base::Time delete_begin_;
 
   // End time to delete to.
   base::Time delete_end_;
 
@@ skipping 43 matching lines @@
 
   // We do not own this.
   content::StoragePartition* storage_partition_for_testing_ = nullptr;
 
   base::WeakPtrFactory<BrowsingDataRemover> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemover);
 };
 
 #endif  // CHROME_BROWSER_BROWSING_DATA_BROWSING_DATA_REMOVER_H_