Notify DataUseTabModel of navigations and tab closures

chrome/browser/android/data_usage/data_use_ui_tab_model_unittest.cc

Index: chrome/browser/android/data_usage/data_use_ui_tab_model_unittest.cc
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 47ddf55444ea5b18cb57b01085df9b15cdd23616..5b514d2d0821aec0c351b77b63dc5f4f1b629d08 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
@@ -6,10 +6,20 @@
 
 #include <stdint.h>
 
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "chrome/browser/android/data_usage/data_use_tab_model.h"
 #include "chrome/browser/android/data_usage/data_use_ui_tab_model_factory.h"
+#include "chrome/browser/android/data_usage/external_data_use_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.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 "content/public/browser/web_contents.h"
 #include "content/public/test/test_renderer_host.h"
 #include "content/public/test/web_contents_tester.h"
@@ -21,35 +31,188 @@ namespace chrome {
 
 namespace android {
 
+namespace {
+
+class TestDataUseTabModel : public DataUseTabModel {
+ public:
+  TestDataUseTabModel(
+      ExternalDataUseObserver* external_data_use_observer,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
+      : DataUseTabModel(external_data_use_observer, ui_task_runner) {}
+
+  ~TestDataUseTabModel() override {}
+
+  using DataUseTabModel::NotifyObserversOfTrackingStarting;
+  using DataUseTabModel::NotifyObserversOfTrackingEnding;
+};
+
 class DataUseUITabModelTest : public ChromeRenderViewHostTestHarness {

[sclittle, 2015/11/24 23:07:37]

Do you really need a full render view test harness here, or could you just make
do with simulating the different tab events and using a test browser context?

Then, you could use a TestBrowserThreadBundle with IO_MAINLOOP (which can't be
used with RenderViewHostTestHarness), which would make any cross-thread testing
here MUCH easier since then the IO thread and the UI thread would use the same
MessageLoop, meaning that you could just call RunUntilIdle() and that would
cover both IO and UI threads.

https://code.google.com/p/chromium/codesearch#chromium/src/content/public/tes...

[tbansal1, 2015/11/25 20:55:16]

Yes, because it uses ChromeRenderViewHostTestHarness::web_contents

  public:
   using ChromeRenderViewHostTestHarness::web_contents;
 
   DataUseUITabModel* data_use_ui_tab_model() {
+    DataUseUITabModel* data_use_ui_tab_model = data_use_ui_tab_model_private();
+    base::RunLoop().RunUntilIdle();

[sclittle, 2015/11/24 23:07:37]

Why is this here? This shouldn't need to be here.

[tbansal1, 2015/11/25 20:55:16]

Done.

+    return data_use_ui_tab_model;
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() const {
+    return io_task_runner_;
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner() const {
+    return ui_task_runner_;
+  }
+
+  ExternalDataUseObserver* external_data_use_observer() const {
+    return external_data_use_observer_.get();
+  }
+
+  TestDataUseTabModel* data_use_tab_model() const {
+    return data_use_tab_model_.get();
+  }
+
+ protected:
+  void SetUp() override {
+    ChromeRenderViewHostTestHarness::SetUp();
+
+    io_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
+        content::BrowserThread::IO);

[sclittle, 2015/11/24 23:07:37]

None of these objects actually live on the IO thread, they all live here on the
UI thread. This doesn't test any of the different thread stuff between the
objects.

You could either switch over to using an IO_MAINLOOP test setup like my comment
above (probably easier), or actually simulate this with a real IO thread
(probably harder).

For example, the TabIdAnnotator test uses a real IO thread by passing around a
base::RunLoop for the UI thread, and posting a Quit task to it later.

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/dat...

[tbansal1, 2015/11/25 20:55:16]

I need the ability to use web_contents, that;s why
ChromeRenderViewHostTestHarness.

+    ui_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
+        content::BrowserThread::UI);
+
+    data_use_aggregator_.reset(
+        new data_usage::DataUseAggregator(nullptr, nullptr));
+
+    external_data_use_observer_.reset(new ExternalDataUseObserver(
+        data_use_aggregator_.get(), io_task_runner(), ui_task_runner()));
+    base::RunLoop().RunUntilIdle();
+
+    data_use_tab_model_.reset(new TestDataUseTabModel(
+        external_data_use_observer(),
+        content::BrowserThread::GetMessageLoopProxyForThread(
+            content::BrowserThread::UI)));
+  }
+
+ private:
+  DataUseUITabModel* data_use_ui_tab_model_private() {
     return chrome::android::DataUseUITabModelFactory::GetForBrowserContext(
         Profile::FromBrowserContext(web_contents()->GetBrowserContext()));
   }
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
+  scoped_ptr<data_usage::DataUseAggregator> data_use_aggregator_;
+  scoped_ptr<ExternalDataUseObserver> external_data_use_observer_;
+  scoped_ptr<TestDataUseTabModel> data_use_tab_model_;
 };
 
-// Tests that DataUseTabModel is notified of tab closure and navigation events.
+}  // namespace
+
+// Tests that DataUseTabModel is notified of tab closure and navigation events,
+// and DataUseTabModel notifies DataUseUITabModel.
 TEST_F(DataUseUITabModelTest, ReportTabEventsTest) {
-  data_use_ui_tab_model()->ReportBrowserNavigation(
-      GURL("https://www.example.com"),
-      ui::PageTransition::PAGE_TRANSITION_TYPED,
-      SessionTabHelper::IdForTab(web_contents()));
-  data_use_ui_tab_model()->ReportTabClosure(
-      SessionTabHelper::IdForTab(web_contents()));
-  // TODO(tbansal): Test that DataUseTabModel is notified.
+  std::string foo_label("foo_label");
+  std::string foo_package("com.foo");
+
+  data_use_ui_tab_model()->SetDataUseTabModel(
+      data_use_tab_model()->GetWeakPtr());
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<std::string> url_regexes;
+  url_regexes.push_back(
+      "http://www[.]foo[.]com/#q=.*|https://www[.]foo[.]com/#q=.*");
+  external_data_use_observer()->RegisterURLRegexes(
+      std::vector<std::string>(url_regexes.size(), foo_package), url_regexes,
+      std::vector<std::string>(url_regexes.size(), foo_label));
+
+  const struct {
+    ui::PageTransition transition_type;
+    std::string expected_label;
+  } tests[] = {
+      {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_TYPED, foo_label},
+      {ui::PageTransition::PAGE_TRANSITION_AUTO_BOOKMARK, std::string()},
+      {ui::PageTransition::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string()},
+      {ui::PageTransition::PAGE_TRANSITION_GENERATED, foo_label},
+      {ui::PageTransition::PAGE_TRANSITION_RELOAD, std::string()},
+  };
+
+  int32_t foo_tab_id = 0;
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    // Start a new tab.
+    ++foo_tab_id;
+    data_use_ui_tab_model()->ReportBrowserNavigation(
+        GURL("https://www.foo.com/#q=abc"), tests[i].transition_type,
+        foo_tab_id);
+    base::RunLoop().RunUntilIdle();
+
+    // |data_use_ui_tab_model| should receive callback about starting of
+    // tracking of data usage for |foo_tab_id|.
+    EXPECT_EQ(!tests[i].expected_label.empty(),
+              data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id))
+        << i;
+    EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id))
+        << i;
+    EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id))
+        << i;
+
+    // DataUse object should be labeled correctly.
+    data_usage::DataUse data_use(GURL("http://foo.com/#q=abc"),
+                                 base::TimeTicks::Now(),
+                                 GURL("http://foobar.com"), foo_tab_id,
+                                 net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
+                                 std::string(), 1000, 1000);
+    std::string got_label;
+    data_use_tab_model()->GetLabelForDataUse(data_use, &got_label);
+    EXPECT_EQ(tests[i].expected_label, got_label) << i;
+
+    // Report closure of tab.
+    data_use_ui_tab_model()->ReportTabClosure(foo_tab_id);
+    base::RunLoop().RunUntilIdle();
+
+    // DataUse object should not be labeled.
+    EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id));
+    data_use.request_start =
+        base::TimeTicks::Now() + base::TimeDelta::FromMinutes(10);
+    data_use_tab_model()->GetLabelForDataUse(data_use, &got_label);
+    EXPECT_EQ(std::string(), got_label) << i;
+  }
+
+  ++foo_tab_id;
+  EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
+  data_use_ui_tab_model()->ReportCustomTabInitialNavigation(
+      foo_tab_id, std::string(), foo_package);
+  base::RunLoop().RunUntilIdle();
+
+  // |data_use_ui_tab_model| should receive callback about starting of
+  // tracking of data usage for |foo_tab_id|.
+  EXPECT_TRUE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
+  EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
+  EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id));
+
+  data_use_ui_tab_model()->ReportTabClosure(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id));
 }
 
 // Tests if the Entrance/Exit UI state is tracked correctly.
 TEST_F(DataUseUITabModelTest, EntranceExitState) {
+  data_use_ui_tab_model()->SetDataUseTabModel(
+      data_use_tab_model()->GetWeakPtr());
+  base::RunLoop().RunUntilIdle();
+
   int32_t foo_tab_id = 1;
   int32_t bar_tab_id = 2;
   int32_t baz_tab_id = 3;
 
-  // ShowEntrance should return true only once.
-  data_use_ui_tab_model()->OnTrackingStarted(foo_tab_id);
+  // HasDataUseTrackingStarted should return true only once.
+  data_use_tab_model()->NotifyObserversOfTrackingStarting(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id));
@@ -57,30 +220,36 @@ TEST_F(DataUseUITabModelTest, EntranceExitState) {
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(bar_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(bar_tab_id));
 
-  // ShowExit should return true only once.
-  data_use_ui_tab_model()->OnTrackingEnded(foo_tab_id);
+  // HasDataUseTrackingEnded should return true only once.
+  data_use_tab_model()->NotifyObserversOfTrackingEnding(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
   EXPECT_TRUE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(foo_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
 
   // The tab enters the tracking state again.
-  data_use_ui_tab_model()->OnTrackingStarted(foo_tab_id);
+  data_use_tab_model()->NotifyObserversOfTrackingStarting(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
 
   // The tab exits the tracking state.
-  data_use_ui_tab_model()->OnTrackingEnded(foo_tab_id);
+  data_use_tab_model()->NotifyObserversOfTrackingEnding(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
 
   // The tab enters the tracking state again.
-  data_use_ui_tab_model()->OnTrackingStarted(foo_tab_id);
-  data_use_ui_tab_model()->OnTrackingStarted(foo_tab_id);
+  data_use_tab_model()->NotifyObserversOfTrackingStarting(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
+  data_use_tab_model()->NotifyObserversOfTrackingStarting(foo_tab_id);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(foo_tab_id));
 
   // ShowExit should return true only once.
-  data_use_ui_tab_model()->OnTrackingEnded(bar_tab_id);
+  data_use_tab_model()->NotifyObserversOfTrackingEnding(bar_tab_id);
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(bar_tab_id));
   EXPECT_TRUE(data_use_ui_tab_model()->HasDataUseTrackingEnded(bar_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(bar_tab_id));
@@ -90,12 +259,75 @@ TEST_F(DataUseUITabModelTest, EntranceExitState) {
   data_use_ui_tab_model()->ReportTabClosure(bar_tab_id);
 
   //  HasDataUseTrackingStarted/Ended should return false for closed tabs.
-  data_use_ui_tab_model()->OnTrackingStarted(baz_tab_id);
+  data_use_tab_model()->NotifyObserversOfTrackingStarting(baz_tab_id);
+  base::RunLoop().RunUntilIdle();
   data_use_ui_tab_model()->ReportTabClosure(baz_tab_id);
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(baz_tab_id));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingEnded(baz_tab_id));
 }
 
+// Checks if page transition type is converted correctly.
+TEST_F(DataUseUITabModelTest, ConvertTransitionType) {
+  data_use_ui_tab_model()->SetDataUseTabModel(
+      data_use_tab_model()->GetWeakPtr());
+  DataUseTabModel::TransitionType transition_type;
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_TYPED), &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_TYPED | 0xFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_TYPED | 0xFFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_TYPED | 0x12FFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_NAVIGATION, transition_type);
+
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_AUTO_BOOKMARK), &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_BOOKMARK, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_AUTO_BOOKMARK | 0xFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_BOOKMARK, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_AUTO_BOOKMARK | 0xFFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_BOOKMARK, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_AUTO_BOOKMARK | 0x12FFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_BOOKMARK, transition_type);
+
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_GENERATED), &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_GENERATED | 0xFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_GENERATED | 0xFFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, transition_type);
+  EXPECT_TRUE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_GENERATED | 0x12FFFF00),
+      &transition_type));
+  EXPECT_EQ(DataUseTabModel::TRANSITION_OMNIBOX_SEARCH, 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(
+      ui::PageTransition(ui::PAGE_TRANSITION_MANUAL_SUBFRAME),
+      &transition_type));
+  EXPECT_FALSE(data_use_ui_tab_model()->ConvertTransitionType(
+      ui::PageTransition(ui::PAGE_TRANSITION_FORM_SUBMIT), &transition_type));
+}
+
 }  // namespace android
 
 }  // namespace chrome