Fixes to handle entrance and exit conditions in DataUseTabModel

* Clicking on a link should be counted as entrance condition if the URL
  matches one of the specified regular expression.
* Tabs restored when Chromium starts will be counted as entrance
  condition if the URL matches.
* Navigation from omnibox by typing URL or clicking on a suggestion,
  will be treated as entrance or exit condition depending on the new
  URL.

BUG=558759

Review URL: https://codereview.chromium.org/1493553004

Cr-Commit-Position: refs/heads/master@{#364542}

8 files changed, 255 insertions, 67 deletions

diff --git a/chrome/browser/android/data_usage/data_use_tab_model.cc b/chrome/browser/android/data_usage/data_use_tab_model.cc
index 54e15f4..380fb41 100644
--- a/chrome/browser/android/data_usage/data_use_tab_model.cc
+++ b/chrome/browser/android/data_usage/data_use_tab_model.cc
@@ -77,47 +77,57 @@ void DataUseTabModel::OnNavigationEvent(SessionID::id_type tab_id,
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsValidTabID(tab_id));
 
+  TabEntryMap::const_iterator tab_entry_iterator = active_tabs_.find(tab_id);
+  const std::string old_label =
+      (tab_entry_iterator != active_tabs_.end())
+          ? tab_entry_iterator->second.GetActiveTrackingSessionLabel()
+          : std::string();
+  std::string new_label;
+  bool matches;
+
   switch (transition) {
     case TRANSITION_OMNIBOX_SEARCH:
     case TRANSITION_OMNIBOX_NAVIGATION:
-    case TRANSITION_FROM_EXTERNAL_APP: {
+      // Enter or exit events.
+      if (!url.is_empty()) {
+        matches = data_use_matcher_->MatchesURL(url, &new_label);
+        DCHECK(matches != new_label.empty());
+      }
+      break;
+
+    case TRANSITION_CUSTOM_TAB:
+    case TRANSITION_LINK:
+    case TRANSITION_RELOAD:
       // 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()) {
+      if (!old_label.empty()) {
+        new_label = old_label;
         break;
       }
-      if (transition == TRANSITION_FROM_EXTERNAL_APP) {
-        // Package name should match, for transitions from external app.
-        if (!package.empty() &&
-            data_use_matcher_->MatchesAppPackageName(package, &label)) {
-          DCHECK(!label.empty());
-          start_tracking = true;
-        }
+      // Package name should match, for transitions from external app.
+      if (transition == TRANSITION_CUSTOM_TAB && !package.empty()) {
+        matches = data_use_matcher_->MatchesAppPackageName(package, &new_label);
+        DCHECK_NE(matches, new_label.empty());
       }
-      if (!start_tracking && !url.is_empty() &&
-          data_use_matcher_->MatchesURL(url, &label)) {
-        DCHECK(!label.empty());
-        start_tracking = true;
+      if (new_label.empty() && !url.is_empty()) {
+        matches = data_use_matcher_->MatchesURL(url, &new_label);
+        DCHECK_NE(matches, new_label.empty());
       }
-      if (start_tracking)
-        StartTrackingDataUse(tab_id, label);
       break;
-    }
 
     case TRANSITION_BOOKMARK:
     case TRANSITION_HISTORY_ITEM:
       // Exit events.
-      EndTrackingDataUse(tab_id);
+      DCHECK(new_label.empty());
       break;
 
     default:
       NOTREACHED();
       break;
   }
+  if (!old_label.empty() && new_label.empty())
+    EndTrackingDataUse(tab_id);
+  else if (old_label.empty() && !new_label.empty())
+    StartTrackingDataUse(tab_id, new_label);
 }
 
 void DataUseTabModel::OnTabCloseEvent(SessionID::id_type tab_id) {
diff --git a/chrome/browser/android/data_usage/data_use_tab_model.h b/chrome/browser/android/data_usage/data_use_tab_model.h
index a59b757..0a234fd4 100644
--- a/chrome/browser/android/data_usage/data_use_tab_model.h
+++ b/chrome/browser/android/data_usage/data_use_tab_model.h
@@ -51,9 +51,14 @@ class DataUseTabModel {
     // Navigation from the omnibox to the SRP.
     TRANSITION_OMNIBOX_SEARCH,
 
-    // Navigation from external apps such as AGSA app.
-    // TODO(rajendrant): Remove this if not needed.
-    TRANSITION_FROM_EXTERNAL_APP,
+    // Navigation from external apps that use Custom Tabs.
+    TRANSITION_CUSTOM_TAB,
+
+    // Navigation by clicking a link in the page.
+    TRANSITION_LINK,
+
+    // Navigation by reloading the page or restoring tabs.
+    TRANSITION_RELOAD,
 
     // Navigation from the omnibox when typing a URL.
     TRANSITION_OMNIBOX_NAVIGATION,
diff --git a/chrome/browser/android/data_usage/data_use_tab_model_unittest.cc b/chrome/browser/android/data_usage/data_use_tab_model_unittest.cc
index b76fe5c..a595a14 100644
--- a/chrome/browser/android/data_usage/data_use_tab_model_unittest.cc
+++ b/chrome/browser/android/data_usage/data_use_tab_model_unittest.cc
@@ -39,6 +39,11 @@ const std::string kTestLabel3 = "label_3";
 const int kTabID1 = 1;
 const int kTabID2 = 2;
 const int kTabID3 = 3;
+const std::string kURLFoo = "http://foo.com/";
+const std::string kURLBar = "http://bar.com/";
+const std::string kURLFooBar = "http://foobar.com/";
+const std::string kPackageFoo = "com.google.package.foo";
+const std::string kPackageBar = "com.google.package.bar";
 
 enum TabEntrySize { ZERO = 0, ONE, TWO, THREE };
 
@@ -121,7 +126,8 @@ class DataUseTabModelTest : public testing::Test {
   // Returns true if the tracking session for tab with id |tab_id| is currently
   // active.
   bool IsTrackingDataUse(SessionID::id_type tab_id) const {
-    auto tab_entry_iterator = data_use_tab_model_->active_tabs_.find(tab_id);
+    const auto& tab_entry_iterator =
+        data_use_tab_model_->active_tabs_.find(tab_id);
     if (tab_entry_iterator == data_use_tab_model_->active_tabs_.end())
       return false;
     return tab_entry_iterator->second.IsTrackingDataUse();
@@ -145,8 +151,8 @@ class DataUseTabModelTest : public testing::Test {
   // |expected_label|.
   void ExpectDataUseLabel(SessionID::id_type tab_id,
                           const std::string& expected_label) const {
-    ExpectDataUseLabelAtTimeWithReturn(tab_id, base::TimeTicks::Now(), true,
-                                       expected_label);
+    ExpectDataUseLabelAtTimeWithReturn(tab_id, base::TimeTicks::Now(),
+                                       !expected_label.empty(), expected_label);
   }
 
   // Checks if GetLabelForDataUse labels the DataUse object for |tab_id| with
@@ -157,8 +163,8 @@ class DataUseTabModelTest : public testing::Test {
       const base::TimeTicks& at_time,
       bool expected_return,
       const std::string& expected_label) const {
-    data_usage::DataUse data_use(GURL("http://foo.com"), at_time,
-                                 GURL("http://foobar.com"), tab_id,
+    data_usage::DataUse data_use(GURL(kURLFoo), at_time, GURL(kURLFooBar),
+                                 tab_id,
                                  net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
                                  std::string(), 1000, 1000);
     std::string actual_label;
@@ -503,13 +509,13 @@ TEST_F(DataUseTabModelTest, NavigationEnterEvent) {
   std::vector<std::string> app_package_names, domain_regexes, labels;
 
   // Matching rule with app package name.
-  app_package_names.push_back("com.google.package.foo");
+  app_package_names.push_back(kPackageFoo);
   domain_regexes.push_back(std::string());
   labels.push_back(kTestLabel1);
 
   // Matching rule with regex.
   app_package_names.push_back(std::string());
-  domain_regexes.push_back("http://foo.com/");
+  domain_regexes.push_back(kURLFoo);
   labels.push_back(kTestLabel2);
 
   RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
@@ -518,15 +524,14 @@ TEST_F(DataUseTabModelTest, NavigationEnterEvent) {
   ExpectTabEntrySize(TabEntrySize::ZERO);
 
   data_use_tab_model_->OnNavigationEvent(
-      kTabID1, DataUseTabModel::TRANSITION_FROM_EXTERNAL_APP, GURL(),
-      "com.google.package.foo");
+      kTabID1, DataUseTabModel::TRANSITION_CUSTOM_TAB, GURL(), kPackageFoo);
   ExpectTabEntrySize(TabEntrySize::ONE);
   EXPECT_TRUE(IsTrackingDataUse(kTabID1));
   ExpectDataUseLabel(kTabID1, kTestLabel1);
 
   data_use_tab_model_->OnNavigationEvent(
-      kTabID2, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH,
-      GURL("http://foo.com"), std::string());
+      kTabID2, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, GURL(kURLFoo),
+      std::string());
   ExpectTabEntrySize(TabEntrySize::TWO);
   EXPECT_TRUE(IsTrackingDataUse(kTabID2));
   ExpectDataUseLabel(kTabID2, kTestLabel2);
@@ -539,12 +544,11 @@ TEST_F(DataUseTabModelTest, EmptyNavigationEvent) {
 
   RegisterURLRegexesInDataUseObserver(
       std::vector<std::string>(1, std::string()),
-      std::vector<std::string>(1, "http://foo.com/"),
+      std::vector<std::string>(1, kURLFoo),
       std::vector<std::string>(1, kTestLabel1));
 
   data_use_tab_model_->OnNavigationEvent(
-      kTabID1, DataUseTabModel::TRANSITION_FROM_EXTERNAL_APP, GURL(),
-      std::string());
+      kTabID1, DataUseTabModel::TRANSITION_CUSTOM_TAB, GURL(), std::string());
   EXPECT_FALSE(IsTrackingDataUse(kTabID1));
 
   data_use_tab_model_->OnNavigationEvent(
@@ -559,15 +563,15 @@ TEST_F(DataUseTabModelTest, NavigationEnterAndExitEvent) {
   std::vector<std::string> app_package_names, domain_regexes, labels;
 
   app_package_names.push_back(std::string());
-  domain_regexes.push_back("http://foo.com/");
+  domain_regexes.push_back(kURLFoo);
   labels.push_back(kTestLabel2);
 
   RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
                                       labels);
 
   data_use_tab_model_->OnNavigationEvent(
-      kTabID1, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH,
-      GURL("http://foo.com/"), std::string());
+      kTabID1, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, GURL(kURLFoo),
+      std::string());
   ExpectTabEntrySize(TabEntrySize::ONE);
   EXPECT_TRUE(IsTrackingDataUse(kTabID1));
 }
@@ -580,27 +584,31 @@ TEST_F(DataUseTabModelTest, AllNavigationEnterEvents) {
     std::string package;
     std::string expect_label;
   } all_enter_transition_tests[] = {
-      {DataUseTabModel::TRANSITION_FROM_EXTERNAL_APP, std::string(),
-       "com.google.package.foo", kTestLabel1},
-      {DataUseTabModel::TRANSITION_FROM_EXTERNAL_APP, "http://foo.com",
-       "com.google.package.nomatch", kTestLabel2},
-      {DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, "http://foo.com",
-       std::string(), kTestLabel2},
+      {DataUseTabModel::TRANSITION_CUSTOM_TAB, std::string(), kPackageFoo,
+       kTestLabel1},
+      {DataUseTabModel::TRANSITION_CUSTOM_TAB, kURLFoo, kPackageBar,
+       kTestLabel2},
+      {DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, kURLFoo, std::string(),
+       kTestLabel2},
+      {DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, kURLFoo, std::string(),
+       kTestLabel2},
+      {DataUseTabModel::TRANSITION_LINK, kURLFoo, std::string(), kTestLabel2},
+      {DataUseTabModel::TRANSITION_RELOAD, kURLFoo, std::string(), kTestLabel2},
   };
   std::vector<std::string> app_package_names, domain_regexes, labels;
   SessionID::id_type tab_id = 1;
 
-  app_package_names.push_back("com.google.package.foo");
+  app_package_names.push_back(kPackageFoo);
   domain_regexes.push_back(std::string());
   labels.push_back(kTestLabel1);
   app_package_names.push_back(std::string());
-  domain_regexes.push_back("http://foo.com/");
+  domain_regexes.push_back(kURLFoo);
   labels.push_back(kTestLabel2);
 
   RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
                                       labels);
 
-  for (auto test : all_enter_transition_tests) {
+  for (const auto& test : all_enter_transition_tests) {
     EXPECT_FALSE(IsTrackingDataUse(tab_id));
     ExpectEmptyDataUseLabel(tab_id);
 
@@ -617,28 +625,73 @@ TEST_F(DataUseTabModelTest, AllNavigationEnterEvents) {
 
 // Tests that any of the Exit transition events end the tracking.
 TEST_F(DataUseTabModelTest, AllNavigationExitEvents) {
-  DataUseTabModel::TransitionType all_exit_transitions[] = {
-      DataUseTabModel::TRANSITION_BOOKMARK,
-      DataUseTabModel::TRANSITION_HISTORY_ITEM};
+  const struct {
+    DataUseTabModel::TransitionType transition;
+    std::string url;
+  } all_exit_transition_tests[] = {
+      {DataUseTabModel::TRANSITION_BOOKMARK, std::string()},
+      {DataUseTabModel::TRANSITION_HISTORY_ITEM, std::string()},
+      {DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, kURLFooBar},
+      {DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, kURLFooBar},
+  };
   std::vector<std::string> app_package_names, domain_regexes, labels;
   SessionID::id_type tab_id = 1;
 
   app_package_names.push_back(std::string());
-  domain_regexes.push_back("http://foo.com/");
+  domain_regexes.push_back(kURLFoo);
   labels.push_back(kTestLabel1);
 
   RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
                                       labels);
 
-  for (auto exit_transition : all_exit_transitions) {
+  for (const auto& test : all_exit_transition_tests) {
     EXPECT_FALSE(IsTrackingDataUse(tab_id));
     data_use_tab_model_->OnNavigationEvent(
-        tab_id, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH,
-        GURL("http://foo.com"), std::string());
+        tab_id, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, GURL(kURLFoo),
+        std::string());
+    EXPECT_TRUE(IsTrackingDataUse(tab_id));
+
+    // Tracking should end.
+    data_use_tab_model_->OnNavigationEvent(tab_id, test.transition,
+                                           GURL(test.url), std::string());
+
+    EXPECT_FALSE(IsTrackingDataUse(tab_id));
+    ExpectTabEntrySize(tab_id);
+    ++tab_id;
+  }
+}
+
+// Tests that transition events that can be enter or exit, are able to start and
+// end the tracking with correct labels.
+TEST_F(DataUseTabModelTest, AllNavigationExitAndEnterEvents) {
+  const DataUseTabModel::TransitionType all_test_transitions[] = {
+      DataUseTabModel::TRANSITION_OMNIBOX_SEARCH,
+      DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION};
+  std::vector<std::string> app_package_names, domain_regexes, labels;
+  SessionID::id_type tab_id = 1;
+
+  app_package_names.push_back(std::string());
+  domain_regexes.push_back(kURLFoo);
+  labels.push_back(kTestLabel1);
+
+  RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
+                                      labels);
+
+  for (const auto& transition : all_test_transitions) {
+    EXPECT_FALSE(IsTrackingDataUse(tab_id));
+    data_use_tab_model_->OnNavigationEvent(tab_id, transition, GURL(kURLFoo),
+                                           std::string());
     EXPECT_TRUE(IsTrackingDataUse(tab_id));
+    ExpectDataUseLabel(tab_id, kTestLabel1);
+
+    // No change in label.
+    data_use_tab_model_->OnNavigationEvent(tab_id, transition, GURL(kURLFoo),
+                                           std::string());
+    EXPECT_TRUE(IsTrackingDataUse(tab_id));
+    ExpectDataUseLabel(tab_id, kTestLabel1);
 
     // Tracking should end.
-    data_use_tab_model_->OnNavigationEvent(tab_id, exit_transition, GURL(),
+    data_use_tab_model_->OnNavigationEvent(tab_id, transition, GURL(),
                                            std::string());
 
     EXPECT_FALSE(IsTrackingDataUse(tab_id));
@@ -647,6 +700,83 @@ TEST_F(DataUseTabModelTest, AllNavigationExitEvents) {
   }
 }
 
+// Tests that a sequence of transitions simulating user actions are able to
+// start and end the tracking with correct label.
+TEST_F(DataUseTabModelTest, SingleTabTransitionSequence) {
+  std::vector<std::string> app_package_names, domain_regexes, labels;
+  SessionID::id_type tab_id = kTabID1;
+  MockTabDataUseObserver mock_observer;
+
+  enum ObserverEvent {
+    OBSERVE_EVENT_NONE,
+    OBSERVE_EVENT_STARTED,
+    OBSERVE_EVENT_ENDED
+  };
+  const struct {
+    DataUseTabModel::TransitionType transition;
+    std::string url;
+    std::string package;
+    std::string expected_label;
+    ObserverEvent observer_event;
+  } transition_tests[] = {
+      // Opening Custom Tab starts tracking.
+      {DataUseTabModel::TRANSITION_CUSTOM_TAB, std::string(), kPackageFoo,
+       kTestLabel1, ObserverEvent::OBSERVE_EVENT_STARTED},
+      // Clicking on links in the page continues tracking.
+      {DataUseTabModel::TRANSITION_LINK, kURLBar, std::string(), kTestLabel1,
+       ObserverEvent::OBSERVE_EVENT_NONE},
+      {DataUseTabModel::TRANSITION_LINK, kURLFooBar, std::string(), kTestLabel1,
+       ObserverEvent::OBSERVE_EVENT_NONE},
+      // Navigating to a non matching URL from omnibox ends tracking.
+      {DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, kURLBar, std::string(),
+       std::string(), ObserverEvent::OBSERVE_EVENT_ENDED},
+      // Clicking on non matching URL links in the page does not start tracking.
+      {DataUseTabModel::TRANSITION_LINK, kURLFooBar, std::string(),
+       std::string(), ObserverEvent::OBSERVE_EVENT_NONE},
+      // Clicking on matching URL links in the page starts tracking.
+      {DataUseTabModel::TRANSITION_LINK, kURLFoo, std::string(), kTestLabel2,
+       ObserverEvent::OBSERVE_EVENT_STARTED},
+      // Navigating to bookmarks ends tracking.
+      {DataUseTabModel::TRANSITION_BOOKMARK, std::string(), std::string(),
+       std::string(), ObserverEvent::OBSERVE_EVENT_ENDED},
+      // Navigating to a matching URL from omnibox starts tracking.
+      {DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, kURLFoo, std::string(),
+       kTestLabel2, ObserverEvent::OBSERVE_EVENT_STARTED},
+      // Navigating to history item ends tracking.
+      {DataUseTabModel::TRANSITION_HISTORY_ITEM, std::string(), std::string(),
+       std::string(), ObserverEvent::OBSERVE_EVENT_ENDED},
+  };
+
+  app_package_names.push_back(kPackageFoo);
+  domain_regexes.push_back(std::string());
+  labels.push_back(kTestLabel1);
+  app_package_names.push_back(std::string());
+  domain_regexes.push_back(kURLFoo);
+  labels.push_back(kTestLabel2);
+  RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
+                                      labels);
+
+  data_use_tab_model_->AddObserver(mock_observer.GetWeakPtr());
+  for (auto const& test : transition_tests) {
+    data_use_tab_model_->AdvanceTime(base::TimeDelta::FromSeconds(1));
+    data_use_tab_model_->OnNavigationEvent(tab_id, test.transition,
+                                           GURL(test.url), test.package);
+    data_use_tab_model_->AdvanceTime(base::TimeDelta::FromSeconds(1));
+
+    EXPECT_EQ(!test.expected_label.empty(), IsTrackingDataUse(tab_id));
+    ExpectDataUseLabel(tab_id, test.expected_label);
+
+    EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID1))
+        .Times(test.observer_event == ObserverEvent::OBSERVE_EVENT_STARTED ? 1
+                                                                           : 0);
+    EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID1))
+        .Times(test.observer_event == ObserverEvent::OBSERVE_EVENT_ENDED ? 1
+                                                                         : 0);
+    base::RunLoop().RunUntilIdle();
+    testing::Mock::VerifyAndClearExpectations(&mock_observer);
+  }
+}
+
 }  // namespace android
 
 }  // namespace chrome
diff --git a/chrome/browser/android/data_usage/data_use_ui_tab_model.cc b/chrome/browser/android/data_usage/data_use_ui_tab_model.cc
index d07a442..1817412 100644
--- a/chrome/browser/android/data_usage/data_use_ui_tab_model.cc
+++ b/chrome/browser/android/data_usage/data_use_ui_tab_model.cc
@@ -71,8 +71,8 @@ void DataUseUITabModel::ReportCustomTabInitialNavigation(
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DataUseTabModel::OnNavigationEvent, data_use_tab_model_,
-                 tab_id, DataUseTabModel::TRANSITION_FROM_EXTERNAL_APP,
-                 GURL(url), package_name));
+                 tab_id, DataUseTabModel::TRANSITION_CUSTOM_TAB, GURL(url),
+                 package_name));
 }
 
 void DataUseUITabModel::SetDataUseTabModel(
@@ -148,7 +148,9 @@ bool DataUseUITabModel::ConvertTransitionType(
     ui::PageTransition page_transition,
     DataUseTabModel::TransitionType* transition_type) const {
   if (!ui::PageTransitionIsMainFrame(page_transition) ||
-      !ui::PageTransitionIsNewNavigation(page_transition)) {
+      (((page_transition & ui::PAGE_TRANSITION_CORE_MASK) !=
+        ui::PAGE_TRANSITION_RELOAD) &&
+       !ui::PageTransitionIsNewNavigation(page_transition))) {
     return false;
   }
 
@@ -159,7 +161,9 @@ bool DataUseUITabModel::ConvertTransitionType(
         *transition_type = DataUseTabModel::TRANSITION_BOOKMARK;
         return true;
       }
-      return false;  // Newtab, clicking on a link.
+      // Newtab, clicking on a link.
+      *transition_type = DataUseTabModel::TRANSITION_LINK;
+      return true;
     case ui::PAGE_TRANSITION_TYPED:
       *transition_type = DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION;
       return true;
@@ -176,7 +180,13 @@ bool DataUseUITabModel::ConvertTransitionType(
       *transition_type = DataUseTabModel::TRANSITION_OMNIBOX_SEARCH;
       return true;
     case ui::PAGE_TRANSITION_RELOAD:
-      // Restored tabs.
+      if ((page_transition & ui::PAGE_TRANSITION_FORWARD_BACK) == 0) {
+        // Restored tabs or user reloaded the page.
+        // TODO(rajendrant): Handle only the tab restore case. We are only
+        // interested in that.
+        *transition_type = DataUseTabModel::TRANSITION_RELOAD;
+        return true;
+      }
       return false;
     default:
       return false;
diff --git a/chrome/browser/android/data_usage/data_use_ui_tab_model_unittest.cc b/chrome/browser/android/data_usage/data_use_ui_tab_model_unittest.cc
index 3780ab3..936d8e3 100644
--- a/chrome/browser/android/data_usage/data_use_ui_tab_model_unittest.cc
+++ b/chrome/browser/android/data_usage/data_use_ui_tab_model_unittest.cc
@@ -122,12 +122,12 @@ TEST_F(DataUseUITabModelTest, ReportTabEventsTest) {
       {ui::PageTransitionFromInt(ui::PageTransition::PAGE_TRANSITION_LINK |
                                  ui::PAGE_TRANSITION_FROM_API),
        std::string()},
-      {ui::PageTransition::PAGE_TRANSITION_LINK, std::string()},
+      {ui::PageTransition::PAGE_TRANSITION_LINK, kFooLabel},
       {ui::PageTransition::PAGE_TRANSITION_TYPED, kFooLabel},
       {ui::PageTransition::PAGE_TRANSITION_AUTO_BOOKMARK, std::string()},
       {ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string()},
       {ui::PageTransition::PAGE_TRANSITION_GENERATED, kFooLabel},
-      {ui::PageTransition::PAGE_TRANSITION_RELOAD, std::string()},
+      {ui::PageTransition::PAGE_TRANSITION_RELOAD, kFooLabel},
   };
 
   SessionID::id_type foo_tab_id = 100;
@@ -304,6 +304,28 @@ TEST_F(DataUseUITabModelTest, ConvertTransitionType) {
       &transition_type));
   EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, transition_type);
 
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_RELOAD), &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_RELOAD, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_RELOAD | 0xFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_RELOAD, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_RELOAD | 0xFFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_RELOAD, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_RELOAD | 0x12FFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_RELOAD, transition_type);
+
+  // Navigating back or forward.
+  EXPECT_FALSE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_RELOAD |
+                         ui::PAGE_TRANSITION_FORWARD_BACK),
+      &transition_type));
+
   EXPECT_FALSE(data_use_ui_tab_model()->ConvertTransitionType(
       ui::PageTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME), &transition_type));
   EXPECT_FALSE(data_use_ui_tab_model()->ConvertTransitionType(
diff --git a/chrome/browser/android/data_usage/tab_data_use_entry.cc b/chrome/browser/android/data_usage/tab_data_use_entry.cc
index 356adca..4d54a09 100644
--- a/chrome/browser/android/data_usage/tab_data_use_entry.cc
+++ b/chrome/browser/android/data_usage/tab_data_use_entry.cc
@@ -194,6 +194,13 @@ const base::TimeTicks TabDataUseEntry::GetLatestStartOrEndTime() const {
   return back_iterator->start_time;
 }
 
+const std::string TabDataUseEntry::GetActiveTrackingSessionLabel() const {
+  TabSessions::const_reverse_iterator back_iterator = sessions_.rbegin();
+  if (back_iterator == sessions_.rend() || !IsTrackingDataUse())
+    return std::string();
+  return back_iterator->label;
+}
+
 void TabDataUseEntry::CompactSessionHistory() {
   while (sessions_.size() > max_sessions_per_tab_) {
     const auto& front = sessions_.front();
diff --git a/chrome/browser/android/data_usage/tab_data_use_entry.h b/chrome/browser/android/data_usage/tab_data_use_entry.h
index 460f799..cfaccf2 100644
--- a/chrome/browser/android/data_usage/tab_data_use_entry.h
+++ b/chrome/browser/android/data_usage/tab_data_use_entry.h
@@ -81,6 +81,10 @@ class TabDataUseEntry {
   // time will be null if no tracking session was ever started or ended.
   const base::TimeTicks GetLatestStartOrEndTime() const;
 
+  // Returns the tracking label for the active tracking session. Empty string is
+  // returned if tracking session is not active.
+  const std::string GetActiveTrackingSessionLabel() const;
+
  private:
   friend class TabDataUseEntryTest;
   friend class MockTabDataUseEntryTest;
diff --git a/chrome/browser/android/data_usage/tab_data_use_entry_unittest.cc b/chrome/browser/android/data_usage/tab_data_use_entry_unittest.cc
index 9927fcd..c04fca72 100644
--- a/chrome/browser/android/data_usage/tab_data_use_entry_unittest.cc
+++ b/chrome/browser/android/data_usage/tab_data_use_entry_unittest.cc
@@ -253,7 +253,7 @@ class MockTabDataUseEntryTest : public testing::Test {
 
   // Returns true if a tracking session is found labeled with |label|.
   bool IsTabEntrySessionExists(const std::string& label) const {
-    for (auto session : tab_entry_->sessions_) {
+    for (const auto& session : tab_entry_->sessions_) {
       if (session.label == label)
         return true;
     }