Notify DataUseTabModel of navigations and tab closures

chrome/browser/android/data_usage/data_use_tab_model_unittest.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 <stdint.h>
 
 #include <string>
 
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.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 "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "components/data_usage/core/data_use.h"
 #include "components/data_usage/core/data_use_aggregator.h"
 #include "components/data_usage/core/data_use_amortizer.h"
 #include "components/data_usage/core/data_use_annotator.h"
+#include "content/public/browser/browser_thread.h"
 #include "net/base/network_change_notifier.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Tracking labels for tests.
 const std::string kTestLabel1 = "label_1";
 const std::string kTestLabel2 = "label_2";
 const std::string kTestLabel3 = "label_3";
@@ skipping 32 matching lines @@
   // Returns the current time advanced by |now_offset_|.
   base::TimeTicks Now() const override {
     return base::TimeTicks::Now() + now_offset_;
   }
 
   // Represents the delta offset to be added to current time that is returned by
   // Now.
   base::TimeDelta now_offset_;
 };
 
-class DataUseTabModelTest : public testing::Test {
+class DataUseTabModelTest : public ChromeRenderViewHostTestHarness {
  public:
   DataUseTabModelTest() {}
 
  protected:
   void SetUp() override {
+    ChromeRenderViewHostTestHarness::SetUp();
+
     data_use_aggregator_.reset(new data_usage::DataUseAggregator(
         scoped_ptr<data_usage::DataUseAnnotator>(),
         scoped_ptr<data_usage::DataUseAmortizer>()));
     data_use_observer_.reset(new ExternalDataUseObserver(
-        data_use_aggregator_.get(), message_loop_.task_runner().get(),
-        message_loop_.task_runner().get()));
+        data_use_aggregator_.get(),
+        content::BrowserThread::GetMessageLoopProxyForThread(
+            content::BrowserThread::IO),
+        content::BrowserThread::GetMessageLoopProxyForThread(
+            content::BrowserThread::UI)));
     data_use_tab_model_ = new DataUseTabModelNowTest(
-        data_use_observer_.get(), message_loop_.task_runner().get());
+        data_use_observer_.get(),
+        content::BrowserThread::GetMessageLoopProxyForThread(
+            content::BrowserThread::UI));
 
     // |data_use_tab_model_| will be owned by |data_use_observer_|.
     data_use_observer_->data_use_tab_model_.reset(data_use_tab_model_);
   }
 
   // Returns true if tab entry for |tab_id| exists in |active_tabs_|.
   bool IsTabEntryExists(int32_t tab_id) const {
     return data_use_tab_model_->active_tabs_.find(tab_id) !=
            data_use_tab_model_->active_tabs_.end();
   }
@@ skipping 69 matching lines @@
     data_use_observer_->RegisterURLRegexes(app_package_names, domain_regexes,
                                            labels);
   }
 
   scoped_ptr<data_usage::DataUseAggregator> data_use_aggregator_;
   scoped_ptr<ExternalDataUseObserver> data_use_observer_;
 
   // Pointer to the tab model within and owned by ExternalDataUseObserver.
   DataUseTabModelNowTest* data_use_tab_model_;
 
-  base::MessageLoop message_loop_;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DataUseTabModelTest);
 };
 
 // Mock observer to track the calls to start and end tracking events.
 class MockTabDataUseObserver : public DataUseTabModel::TabDataUseObserver {
  public:
+  MockTabDataUseObserver() : weak_ptr_factory_(this) {}
   MOCK_METHOD1(NotifyTrackingStarting, void(int32_t tab_id));
   MOCK_METHOD1(NotifyTrackingEnding, void(int32_t tab_id));
+
+  base::WeakPtr<MockTabDataUseObserver> GetWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
+ private:
+  base::WeakPtrFactory<MockTabDataUseObserver> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockTabDataUseObserver);
 };
 
 // Starts and ends tracking a single tab and checks if its label is returned
 // correctly for DataUse objects.
 TEST_F(DataUseTabModelTest, SingleTabTracking) {
   ExpectTabEntrySize(TabEntrySize::ZERO);
 
   // No label is applied initially.
   ExpectEmptyDataUseLabel(kTabID1);
   ExpectEmptyDataUseLabel(kTabID2);
@@ skipping 47 matching lines @@
 }
 
 // Checks that the mock observer receives start and end tracking events for a
 // single tab.
 TEST_F(DataUseTabModelTest, ObserverStartEndEvents) {
   MockTabDataUseObserver mock_observer;
 
   EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID1)).Times(1);
   EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID1)).Times(1);
 
-  data_use_tab_model_->AddObserver(&mock_observer);
+  data_use_tab_model_->AddObserver(&mock_observer, mock_observer.GetWeakPtr());
+  EXPECT_EQ(1U, data_use_tab_model_->observers_.size());
   StartTrackingDataUse(kTabID1, kTestLabel1);
   EndTrackingDataUse(kTabID1);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Checks that multiple mock observers receive start and end tracking events for
 // multiple tabs.
 TEST_F(DataUseTabModelTest, MultipleObserverMultipleStartEndEvents) {
   MockTabDataUseObserver mock_observers[kMaxMockObservers];
+  size_t expected_observer_count = 0;
+  EXPECT_EQ(expected_observer_count, data_use_tab_model_->observers_.size());
 
   for (auto& mock_observer : mock_observers) {
     // Add the observer.
-    data_use_tab_model_->AddObserver(&mock_observer);
+    data_use_tab_model_->AddObserver(&mock_observer,
+                                     mock_observer.GetWeakPtr());
+    ++expected_observer_count;
+    EXPECT_EQ(expected_observer_count, data_use_tab_model_->observers_.size());
 
     // Expect start and end events for tab ids 1-3.
     EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID1)).Times(1);
     EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID1)).Times(1);
     EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID2)).Times(1);
     EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID2)).Times(1);
     EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID3)).Times(1);
     EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID3)).Times(1);
   }
 
   // Start and end tracking for tab ids 1-3.
   StartTrackingDataUse(kTabID1, kTestLabel1);
   StartTrackingDataUse(kTabID2, kTestLabel2);
   StartTrackingDataUse(kTabID3, kTestLabel3);
   EndTrackingDataUse(kTabID1);
   EndTrackingDataUse(kTabID2);
   EndTrackingDataUse(kTabID3);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
+
+  for (auto& mock_observer : mock_observers) {
+    // Remove the observer.
+    data_use_tab_model_->RemoveObserver(&mock_observer);
+    --expected_observer_count;
+    EXPECT_EQ(expected_observer_count, data_use_tab_model_->observers_.size());
+  }
+  EXPECT_EQ(0U, data_use_tab_model_->observers_.size());
 }
 
 // Checks that the observer is not notified of start and end events after
 // RemoveObserver.
 TEST_F(DataUseTabModelTest, ObserverNotNotifiedAfterRemove) {
   MockTabDataUseObserver mock_observer;
 
   // Observer notified of start and end events.
   EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID1)).Times(1);
   EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID1)).Times(1);
 
-  data_use_tab_model_->AddObserver(&mock_observer);
+  EXPECT_EQ(0U, data_use_tab_model_->observers_.size());
+  data_use_tab_model_->AddObserver(&mock_observer, mock_observer.GetWeakPtr());
+  EXPECT_EQ(1U, data_use_tab_model_->observers_.size());
   StartTrackingDataUse(kTabID1, kTestLabel1);
   EndTrackingDataUse(kTabID1);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   testing::Mock::VerifyAndClear(&mock_observer);
 
   // Observer should not be notified after RemoveObserver.
   EXPECT_CALL(mock_observer, NotifyTrackingStarting(kTabID1)).Times(0);
   EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID1)).Times(0);
 
   data_use_tab_model_->RemoveObserver(&mock_observer);
+  EXPECT_EQ(0U, data_use_tab_model_->observers_.size());
   StartTrackingDataUse(kTabID1, kTestLabel1);
   EndTrackingDataUse(kTabID1);
 
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Checks that tab close event updates the close time of the tab entry.
 TEST_F(DataUseTabModelTest, TabCloseEvent) {
   StartTrackingDataUse(kTabID1, kTestLabel1);
   EndTrackingDataUse(kTabID1);
 
   ExpectTabEntrySize(TabEntrySize::ONE);
   EXPECT_TRUE(
       data_use_tab_model_->active_tabs_[kTabID1].tab_close_time_.is_null());
@@ skipping 18 matching lines @@
       kTabID1, base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(20));
 }
 
 // Checks that end tracking for specific labels closes those active sessions.
 TEST_F(DataUseTabModelTest, OnTrackingLabelRemoved) {
   MockTabDataUseObserver mock_observer;
 
   StartTrackingDataUse(kTabID1, kTestLabel1);
   StartTrackingDataUse(kTabID2, kTestLabel2);
   StartTrackingDataUse(kTabID3, kTestLabel3);
-  data_use_tab_model_->AddObserver(&mock_observer);
+  data_use_tab_model_->AddObserver(&mock_observer, mock_observer.GetWeakPtr());
   ExpectTabEntrySize(TabEntrySize::THREE);
 
   EXPECT_TRUE(IsTrackingDataUse(kTabID1));
   EXPECT_TRUE(IsTrackingDataUse(kTabID2));
   EXPECT_TRUE(IsTrackingDataUse(kTabID3));
 
   // Observer notified of end tracking.
   EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID2)).Times(1);
 
   data_use_tab_model_->OnTrackingLabelRemoved(kTestLabel2);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(IsTrackingDataUse(kTabID1));
   EXPECT_FALSE(IsTrackingDataUse(kTabID2));
   EXPECT_TRUE(IsTrackingDataUse(kTabID3));
 
   EXPECT_CALL(mock_observer, NotifyTrackingEnding(kTabID3)).Times(1);
 
   data_use_tab_model_->OnTrackingLabelRemoved(kTestLabel3);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(IsTrackingDataUse(kTabID1));
   EXPECT_FALSE(IsTrackingDataUse(kTabID2));
   EXPECT_FALSE(IsTrackingDataUse(kTabID3));
 }
 
 // Checks that |active_tabs_| does not grow beyond GetMaxTabEntriesForTests tab
 // entries.
 TEST_F(DataUseTabModelTest, CompactTabEntriesWithinMaxLimit) {
   const size_t max_tab_entries = data_use_tab_model_->max_tab_entries_;
@@ skipping 169 matching lines @@
   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());
   ExpectTabEntrySize(TabEntrySize::ONE);
   EXPECT_TRUE(IsTrackingDataUse(kTabID1));
-
-  data_use_tab_model_->OnNavigationEvent(
-      kTabID1, DataUseTabModel::TRANSITION_FROM_NAVSUGGEST, GURL(),
-      std::string());
-  EXPECT_FALSE(IsTrackingDataUse(kTabID1));
 }
 
 // Tests that any of the Enter transition events start the tracking.
 TEST_F(DataUseTabModelTest, AllNavigationEnterEvents) {
   const struct {
     DataUseTabModel::TransitionType transition;
     std::string url;
     std::string package;
     std::string expect_label;
   } all_enter_transition_tests[] = {
@@ skipping 28 matching lines @@
     EXPECT_TRUE(IsTrackingDataUse(tab_id));
     ExpectDataUseLabel(tab_id, test.expect_label);
     ExpectTabEntrySize(tab_id);
     ++tab_id;
   }
 }
 
 // Tests that any of the Exit transition events end the tracking.
 TEST_F(DataUseTabModelTest, AllNavigationExitEvents) {
   DataUseTabModel::TransitionType all_exit_transitions[] = {
-      DataUseTabModel::TRANSITION_TO_EXTERNAL_APP,
-      DataUseTabModel::TRANSITION_FROM_NAVSUGGEST,
-      DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION,
       DataUseTabModel::TRANSITION_BOOKMARK,
       DataUseTabModel::TRANSITION_HISTORY_ITEM};
   std::vector<std::string> app_package_names, domain_regexes, labels;
   int32_t tab_id = 1;
 
   app_package_names.push_back(std::string());
   domain_regexes.push_back("http://foo.com/");
   labels.push_back(kTestLabel1);
 
   RegisterURLRegexesInDataUseObserver(app_package_names, domain_regexes,
@@ skipping 12 matching lines @@
 
     EXPECT_FALSE(IsTrackingDataUse(tab_id));
     ExpectTabEntrySize(tab_id);
     ++tab_id;
   }
 }
 
 }  // namespace android
 
 }  // namespace chrome