Make DataUseTabModel and DataUseMatcher more independent

chrome/browser/android/data_usage/data_use_tab_model.h

 // Copyright 2015 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_ANDROID_DATA_USAGE_DATA_USE_TAB_MODEL_H_
 #define CHROME_BROWSER_ANDROID_DATA_USAGE_DATA_USE_TAB_MODEL_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/data_usage/tab_data_use_entry.h"
 #include "components/sessions/core/session_id.h"
 #include "url/gurl.h"
@@ skipping 74 matching lines @@
     // Notification callback that DataUseTabModel is ready to process the UI
     // navigation events.
     virtual void OnDataUseTabModelReady() = 0;
   };
 
   // The tags to report for data usage from a default chrome tab, and a chrome
   // custom tab.
   static const char kDefaultTag[];
   static const char kCustomTabTag[];
 
-  DataUseTabModel();
-
-  // Initializes |this| on UI thread. |external_data_use_observer_bridge| is the
-  // pointer to ExternalDataUseObserverBridge object. DataUseTabModel and
+  // |external_data_use_observer_bridge| is the pointer to
+  // ExternalDataUseObserverBridge object. DataUseTabModel and
   // ExternalDataUseObserverBridge objects are owned by ExternalDataUseObserver
   // and DataUseTabModel is destroyed first followed by
   // ExternalDataUseObserverBridge.
-  void InitOnUIThread(
-      const ExternalDataUseObserverBridge* external_data_use_observer_bridge);
+  DataUseTabModel(
+      const base::Closure& fetch_matching_rules_callback,
+      const base::Callback<void(bool)>& on_matching_rules_fetched_callback);
+
+  // Initializes |this| on UI thread.
+  void InitOnUIThread();
 
   virtual ~DataUseTabModel();
 
   base::WeakPtr<DataUseTabModel> GetWeakPtr();
 
   // Notifies the DataUseTabModel of navigation events. |tab_id| is the source
   // tab of the generated event, |transition| indicates the type of the UI
   // event/transition,  |url| is the URL in the source tab, |package| indicates
   // the android package name of external application that initiated the event.
   // |navigation_entry| corresponds to the navigation entry of the current
   // navigation in back-forward navigation history, and is used to save the
   // current tracking label to be used for back-forward navigations.
   // |navigation_entry| can be null in some cases where it cannot be retrieved
   // such as buffered navigation events or when support for back-forward
   // navigations is not needed such as custom tab navigation.
   void OnNavigationEvent(SessionID::id_type tab_id,
                          TransitionType transition,
                          const GURL& url,
                          const std::string& package,
                          content::NavigationEntry* navigation_entry);
 
   // Notifies the DataUseTabModel that tab with |tab_id| is closed. Any active
   // tracking sessions for the tab are terminated, and the tab is marked as
   // closed.
   void OnTabCloseEvent(SessionID::id_type tab_id);
 
   // Notifies the DataUseTabModel that tracking label |label| is removed. Any
   // active tracking sessions with the label are ended, without notifying any of
   // the TabDataUseObserver.
-  virtual void OnTrackingLabelRemoved(std::string label);
+  virtual void OnTrackingLabelRemoved(const std::string& label);
 
   // Gets the tracking information for the tab with id |tab_id| at time
   // |timestamp|. |output_info| must not be null. If a tab tracking session is
   // found that was active at |timestamp|, returns true and
   // |output_tracking_info| is populated with its information. Otherwise,
   // returns false.
   virtual bool GetTrackingInfoForTabAtTime(
       SessionID::id_type tab_id,
       base::TimeTicks timestamp,
       TrackingInfo* output_tracking_info) const;
@@ skipping 141 matching lines @@
   // respectively.
   const base::TimeDelta closed_tab_expiration_duration_;
   const base::TimeDelta open_tab_expiration_duration_;
 
   // TickClock used for obtaining the current time.
   std::unique_ptr<base::TickClock> tick_clock_;
 
   // Stores the matching patterns.
   std::unique_ptr<DataUseMatcher> data_use_matcher_;
 
+  // Callback to be run to initiate fetching the matching rules.
+  const base::Closure& fetch_matching_rules_callback_;
+
   // True if DataUseTabModel is ready to process UI navigation events.
   // DataUseTabModel will be considered ready when the first rule fetch is
   // complete or the control app not installed callback was received, whichever
   // is sooner.
   bool is_ready_for_navigation_event_;
 
   // True if the external control app is installed.
   bool is_control_app_installed_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<DataUseTabModel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DataUseTabModel);
 };
 
 }  // namespace android
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_ANDROID_DATA_USAGE_DATA_USE_TAB_MODEL_H_