Notify DataUseTabModel of navigations and tab closures

chrome/browser/android/data_usage/data_use_tab_model.cc

 // 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.
 
 #include "chrome/browser/android/data_usage/data_use_tab_model.h"
 
 #include "base/metrics/histogram_macros.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/data_usage/external_data_use_observer.h"
-#include "chrome/browser/android/data_usage/tab_data_use_entry.h"
+#include "components/data_usage/core/data_use.h"
 #include "components/variations/variations_associated_data.h"
 
 namespace {
 
 // Indicates the default maximum number of tabs to maintain session information
 // about. May be overridden by the field trial.
 const size_t kDefaultMaxTabEntries = 200;
 
 const char kUMAExpiredInactiveTabEntryRemovalDurationSecondsHistogram[] =
     "DataUse.TabModel.ExpiredInactiveTabEntryRemovalDuration";
 const char kUMAExpiredActiveTabEntryRemovalDurationHoursHistogram[] =
     "DataUse.TabModel.ExpiredActiveTabEntryRemovalDuration";
 const char kUMAUnexpiredTabEntryRemovalDurationMinutesHistogram[] =
     "DataUse.TabModel.UnexpiredTabEntryRemovalDuration";
 
 // Returns true if |tab_id| is a valid tab ID.
-bool IsValidTabID(int32_t tab_id) {
+bool IsValidTabID(SessionID::id_type tab_id) {
   return tab_id >= 0;
 }
 
 // Returns various parameters from the values specified in the field trial.
 size_t GetMaxTabEntries() {
   size_t max_tab_entries = -1;
   std::string variation_value = variations::GetVariationParamValue(
       chrome::android::ExternalDataUseObserver::
           kExternalDataUseObserverFieldTrial,
       "max_tab_entries");
   if (!variation_value.empty() &&
       base::StringToSizeT(variation_value, &max_tab_entries)) {
     return max_tab_entries;
   }
   return kDefaultMaxTabEntries;
 }
 
 }  // namespace
 
 namespace chrome {
 
 namespace android {
 
 DataUseTabModel::DataUseTabModel(
     const ExternalDataUseObserver* data_use_observer,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
     : data_use_observer_(data_use_observer),
-      observer_list_(new base::ObserverListThreadSafe<TabDataUseObserver>),
       max_tab_entries_(GetMaxTabEntries()),
-      weak_factory_(this) {}
+      ui_task_runner_(ui_task_runner),
+      weak_factory_(this) {
+  DCHECK(ui_task_runner_);
+}
 
 DataUseTabModel::~DataUseTabModel() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 base::WeakPtr<DataUseTabModel> DataUseTabModel::GetWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_factory_.GetWeakPtr();
 }
 
-void DataUseTabModel::OnNavigationEvent(int32_t tab_id,
+void DataUseTabModel::OnNavigationEvent(SessionID::id_type tab_id,
                                         TransitionType transition,
                                         const GURL& url,
                                         const std::string& package) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsValidTabID(tab_id));
 
   switch (transition) {
     case TRANSITION_OMNIBOX_SEARCH:
+    case TRANSITION_OMNIBOX_NAVIGATION:
     case TRANSITION_FROM_EXTERNAL_APP: {
       // Enter events.
       bool start_tracking = false;
       std::string label;
       TabEntryMap::const_iterator tab_entry_iterator =
           active_tabs_.find(tab_id);
       if (tab_entry_iterator != active_tabs_.end() &&
           tab_entry_iterator->second.IsTrackingDataUse()) {
         break;
       }
       if (transition == TRANSITION_FROM_EXTERNAL_APP) {
         // Package name should match, for transitions from external app.
         if (!package.empty() &&
             data_use_observer_->MatchesAppPackageName(package, &label)) {
           DCHECK(!label.empty());
           start_tracking = true;
         }
       }
       if (!start_tracking && !url.is_empty() &&
           data_use_observer_->Matches(url, &label)) {
         DCHECK(!label.empty());
         start_tracking = true;
       }
       if (start_tracking)
         StartTrackingDataUse(tab_id, label);
       break;
     }
 
-    case TRANSITION_FROM_NAVSUGGEST:
-    case TRANSITION_OMNIBOX_NAVIGATION:
     case TRANSITION_BOOKMARK:
     case TRANSITION_HISTORY_ITEM:
-    case TRANSITION_TO_EXTERNAL_APP:
       // Exit events.
       EndTrackingDataUse(tab_id);
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
-void DataUseTabModel::OnTabCloseEvent(int32_t tab_id) {
+void DataUseTabModel::OnTabCloseEvent(SessionID::id_type tab_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsValidTabID(tab_id));
 
   TabEntryMap::iterator tab_entry_iterator = active_tabs_.find(tab_id);
   if (tab_entry_iterator == active_tabs_.end())
     return;
 
   TabDataUseEntry& tab_entry = tab_entry_iterator->second;
   if (tab_entry.IsTrackingDataUse())
     tab_entry.EndTracking();
@@ skipping 20 matching lines @@
   TabEntryMap::const_iterator tab_entry_iterator =
       active_tabs_.find(data_use.tab_id);
   if (tab_entry_iterator != active_tabs_.end()) {
     return tab_entry_iterator->second.GetLabel(data_use.request_start,
                                                output_label);
   }
 
   return false;  // Tab session not found.
 }
 
-void DataUseTabModel::AddObserver(TabDataUseObserver* observer) {
-  observer_list_->AddObserver(observer);
+void DataUseTabModel::AddObserver(
+    const TabDataUseObserver* observer,
+    const base::WeakPtr<TabDataUseObserver> weak_ptr_observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (observers_.find(observer) != observers_.end()) {
+    NOTREACHED() << " Same TabDataUseObserver can't be added twice";
+    return;
+  }
+  observers_.insert(ObserverMap::value_type(observer, weak_ptr_observer));
+  DCHECK_LT(0U, observers_.size());
 }
 
-void DataUseTabModel::RemoveObserver(TabDataUseObserver* observer) {
-  observer_list_->RemoveObserver(observer);
+void DataUseTabModel::RemoveObserver(const TabDataUseObserver* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (observers_.find(observer) == observers_.end()) {
+    NOTREACHED() << " TabDataUseObserver is not registered as an observer";
+    return;
+  }
+  observers_.erase(observer);
 }
 
 base::TimeTicks DataUseTabModel::Now() const {
   return base::TimeTicks::Now();
 }
 
-void DataUseTabModel::NotifyObserversOfTrackingStarting(int32_t tab_id) {
-  observer_list_->Notify(FROM_HERE, &TabDataUseObserver::NotifyTrackingStarting,
-                         tab_id);
+void DataUseTabModel::NotifyObserversOfTrackingStarting(
+    SessionID::id_type tab_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(ui_task_runner_);
+  for (const auto& it : observers_) {
+    ui_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&TabDataUseObserver::NotifyTrackingStarting,
+                              it.second, tab_id));
+  }
 }
 
-void DataUseTabModel::NotifyObserversOfTrackingEnding(int32_t tab_id) {
-  observer_list_->Notify(FROM_HERE, &TabDataUseObserver::NotifyTrackingEnding,
-                         tab_id);
+void DataUseTabModel::NotifyObserversOfTrackingEnding(
+    SessionID::id_type tab_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(ui_task_runner_);
+  for (const auto& it : observers_) {
+    ui_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&TabDataUseObserver::NotifyTrackingEnding,
+                              it.second, tab_id));
+  }
 }
 
-void DataUseTabModel::StartTrackingDataUse(int32_t tab_id,
+void DataUseTabModel::StartTrackingDataUse(SessionID::id_type tab_id,
                                            const std::string& label) {
   // TODO(rajendrant): Explore ability to handle changes in label for current
   // session.
   bool new_tab_entry_added = false;
   TabEntryMap::iterator tab_entry_iterator = active_tabs_.find(tab_id);
   if (tab_entry_iterator == active_tabs_.end()) {
     auto new_entry =
         active_tabs_.insert(TabEntryMap::value_type(tab_id, TabDataUseEntry()));
     tab_entry_iterator = new_entry.first;
     DCHECK(tab_entry_iterator != active_tabs_.end());
     DCHECK(!tab_entry_iterator->second.IsTrackingDataUse());
     new_tab_entry_added = true;
   }
   if (tab_entry_iterator->second.StartTracking(label))
     NotifyObserversOfTrackingStarting(tab_id);
 
   if (new_tab_entry_added)
     CompactTabEntries();  // Keep total number of tab entries within limit.
 }
 
-void DataUseTabModel::EndTrackingDataUse(int32_t tab_id) {
+void DataUseTabModel::EndTrackingDataUse(SessionID::id_type tab_id) {
   TabEntryMap::iterator tab_entry_iterator = active_tabs_.find(tab_id);
   if (tab_entry_iterator != active_tabs_.end() &&
       tab_entry_iterator->second.EndTracking()) {
     NotifyObserversOfTrackingEnding(tab_id);
   }
 }
 
 void DataUseTabModel::CompactTabEntries() {
   // Remove expired tab entries.
   for (TabEntryMap::iterator tab_entry_iterator = active_tabs_.begin();
@@ skipping 39 matching lines @@
         kUMAUnexpiredTabEntryRemovalDurationMinutesHistogram,
         Now() - oldest_tab_entry_iterator->second.GetLatestStartOrEndTime(),
         base::TimeDelta::FromMinutes(1), base::TimeDelta::FromHours(1), 50);
     active_tabs_.erase(oldest_tab_entry_iterator);
   }
 }
 
 }  // namespace android
 
 }  // namespace chrome