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_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 DataUseTabModelTest : public DataUseTabModel {

[sclittle, 2015/11/16 23:13:43]

nit: Name this TestDataUseTabModel, so that it isn't confused with a test
harness class.

[tbansal1, 2015/11/17 21:12:33]

Done.

+ public:
+  DataUseTabModelTest(ExternalDataUseObserver* external_data_use_observer,
+                      scoped_refptr<base::SingleThreadTaskRunner> task_runner_)
+      : DataUseTabModel(external_data_use_observer, task_runner_.get()),
+        weak_factory_(this) {}
+
+  base::WeakPtr<DataUseTabModelTest> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
+ private:
+  base::WeakPtrFactory<DataUseTabModelTest> weak_factory_;
+};
+
 class DataUseUITabModelTest : public ChromeRenderViewHostTestHarness {
  public:
   using ChromeRenderViewHostTestHarness::web_contents;
 
   DataUseUITabModel* data_use_ui_tab_model() {
     return chrome::android::DataUseUITabModelFactory::GetForBrowserContext(
         Profile::FromBrowserContext(web_contents()->GetBrowserContext()));
   }
 };
 
-// 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");
+
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::IO);
+  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::UI);
+
+  scoped_ptr<data_usage::DataUseAggregator> data_use_aggregator(

[sclittle, 2015/11/16 23:13:42]

nit: This doesn't have to be a scoped_ptr, this could just be a regular object
on the stack.

[tbansal1, 2015/11/17 21:12:33]

Done.

+      new data_usage::DataUseAggregator(
+          scoped_ptr<data_usage::DataUseAnnotator>(),
+          scoped_ptr<data_usage::DataUseAmortizer>()));
+
+  scoped_ptr<ExternalDataUseObserver> external_data_use_observer(

[sclittle, 2015/11/16 23:13:43]

nit: same here, this doesn't need to be a scoped_ptr.

[tbansal1, 2015/11/17 21:12:33]

Done.

+      new ExternalDataUseObserver(data_use_aggregator.get(),
+                                  io_task_runner.get(), ui_task_runner.get()));
+  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));
+
+  DataUseTabModelTest data_use_tab_model(
+      external_data_use_observer.get(),
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::IO));
+  data_use_ui_tab_model()->SetIODataUseTabModel(
+      data_use_tab_model.GetWeakPtr());
+  data_use_ui_tab_model()->SetUIDataUseTabModel(
+      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"),

[sclittle, 2015/11/16 23:13:42]

Add an include for data_use.h

[tbansal1, 2015/11/17 21:12:33]

Done.

+                                 base::TimeTicks::Now(),
+                                 GURL("http://foobar.com"), foo_tab_id,
+                                 net::NetworkChangeNotifier::CONNECTION_UNKNOWN,

[sclittle, 2015/11/16 23:13:42]

nit: Pull this DataUse creation and the DataUse creation below out into a
function, so that it's easier for someone to add a new argument to the DataUse
constructor later.

[tbansal1, 2015/11/17 21:12:33]

Reduced it to one function call.

+                                 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_usage::DataUse data_use_expired(
+        GURL("http://foo.com/#q=abc"), base::TimeTicks::Now(),

[sclittle, 2015/11/16 23:13:43]

base::TimeTicks::Now() could be the same as it was earlier, so this test seems
inherently flaky. If you really want to test timing stuff, you could either use
specific TimeTicks values for each of these and the ReportTabClosure event.

If you can't use specific TimeTicks values, maybe TickClock and
SimpleTestTickClock could be helpful:
https://code.google.com/p/chromium/codesearch#chromium/src/base/time/tick_clo...

[tbansal1, 2015/11/17 21:12:33]

Done.

+        GURL("http://foobar.com"), foo_tab_id,
+        net::NetworkChangeNotifier::CONNECTION_UNKNOWN, std::string(), 1000,
+        1000);
+
+    data_use_tab_model.GetLabelForDataUse(data_use_expired, &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);
+  // HasDataUseTrackingStarted should return true only once.
+  data_use_ui_tab_model()->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.
+  data_use_ui_tab_model()->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);
+  data_use_ui_tab_model()->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);
+  data_use_ui_tab_model()->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);
+  data_use_ui_tab_model()->NotifyTrackingStarting(foo_tab_id);
+  data_use_ui_tab_model()->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);
+  data_use_ui_tab_model()->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);
+  data_use_ui_tab_model()->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