Notify DataUseTabModel of navigations and tab closures

chrome/browser/android/data_usage/data_use_ui_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_ui_tab_model.h"
 
 #include <stdint.h>
 
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.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"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 
 namespace chrome {
 
 namespace android {
 
+class TestDataUseTabModel : public DataUseTabModel {
+ public:
+  TestDataUseTabModel(ExternalDataUseObserver* external_data_use_observer,
+                      scoped_refptr<base::SingleThreadTaskRunner> task_runner_)

[sclittle, 2015/11/17 22:50:12]

What thread is |task_runner_| for? Name it |io_task_runner| or whatever.

Also, remove the trailing "_"

[tbansal1, 2015/11/18 01:32:23]

Done.

+      : DataUseTabModel(external_data_use_observer, task_runner_.get()),
+        weak_factory_(this) {}
+
+  base::WeakPtr<TestDataUseTabModel> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+ private:
+  base::WeakPtrFactory<TestDataUseTabModel> weak_factory_;
+};
+
 class DataUseUITabModelTest : public ChromeRenderViewHostTestHarness {
  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();
+    return data_use_ui_tab_model;
+  }
+
+  void NotifyTrackingStarting(int tab_id) {
+    base::RunLoop().RunUntilIdle();
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DataUseUITabModelTest::NotifyTrackingStartingIO,
+                              base::Unretained(this), tab_id));
+    base::RunLoop().RunUntilIdle();
+  }
+
+  void NotifyTrackingEnding(int tab_id) {
+    base::RunLoop().RunUntilIdle();
+    io_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DataUseUITabModelTest::NotifyTrackingEndingIO,
+                              base::Unretained(this), tab_id));
+    base::RunLoop().RunUntilIdle();
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner() const {
+    return io_task_runner_;
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner() const {
+    return ui_task_runner_;
+  }
+
+ protected:
+  void SetUp() override {
+    ChromeRenderViewHostTestHarness::SetUp();
+
+    io_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
+        content::BrowserThread::IO);
+    ui_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
+        content::BrowserThread::UI);
+  }
+
+ private:
+  DataUseUITabModel* data_use_ui_tab_model_private() {
     return chrome::android::DataUseUITabModelFactory::GetForBrowserContext(
         Profile::FromBrowserContext(web_contents()->GetBrowserContext()));
   }
+
+  void NotifyTrackingStartingIO(int tab_id) {
+    data_use_ui_tab_model()->tab_data_use_observer_->NotifyTrackingStarting(

[sclittle, 2015/11/17 22:50:12]

Instead of reaching into the |tab_data_use_observer_| directly, couldn't you
just make a TestDataUseTabModel notify its observers? That way, you actually
test that the |tab_data_use_observer_| registers itself as an observer properly.

[tbansal1, 2015/11/18 01:32:23]

Done.

+        tab_id);
+  }
+
+  void NotifyTrackingEndingIO(int tab_id) {
+    data_use_ui_tab_model()->tab_data_use_observer_->NotifyTrackingEnding(
+        tab_id);
+  }
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 };
 
-// Tests that DataUseTabModel is notified of tab closure and navigation events.
+// 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");
+
+  data_usage::DataUseAggregator data_use_aggregator(nullptr, nullptr);
+
+  ExternalDataUseObserver external_data_use_observer(
+      &data_use_aggregator, io_task_runner(), ui_task_runner());
+  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(), std::string()), url_regexes,
+      std::vector<std::string>(url_regexes.size(), foo_label));
+
+  TestDataUseTabModel data_use_tab_model(
+      &external_data_use_observer,
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::IO));
+  data_use_ui_tab_model()->SetIODataUseTabModel(
+      data_use_tab_model.GetWeakPtr());
+
+  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()},
+  };
+
+  for (size_t i = 0; i < arraysize(tests); ++i) {
+    // Start a new tab.
+    int32_t foo_tab_id = i + 1;
+    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.
+    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;
+  }
 }
 
 // Tests if the Entrance/Exit UI state is tracked correctly.
 TEST_F(DataUseUITabModelTest, EntranceExitState) {
   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);
+  ASSERT_NE(data_use_ui_tab_model(), nullptr);
+
+  // HasDataUseTrackingStarted should return true only once.
+  NotifyTrackingStarting(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));
 
   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.
+  NotifyTrackingEnding(foo_tab_id);
   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);
+  NotifyTrackingStarting(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));
 
   // The tab exits the tracking state.
-  data_use_ui_tab_model()->OnTrackingEnded(foo_tab_id);
+  NotifyTrackingEnding(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_ui_tab_model()->OnTrackingStarted(foo_tab_id);
+  NotifyTrackingStarting(foo_tab_id);
+  NotifyTrackingStarting(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));
 
   // ShowExit should return true only once.
-  data_use_ui_tab_model()->OnTrackingEnded(bar_tab_id);
+  NotifyTrackingEnding(bar_tab_id);
   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));
   EXPECT_FALSE(data_use_ui_tab_model()->HasDataUseTrackingStarted(bar_tab_id));
 
   data_use_ui_tab_model()->ReportTabClosure(foo_tab_id);
   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);
+  NotifyTrackingStarting(baz_tab_id);
   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) {
+  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