ExternalDataUseObserver matches package names

chrome/browser/android/data_usage/external_data_use_observer_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/external_data_use_observer.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 88 matching lines @@
       {"http://www.google.com:80", "http://www.google.com", false},
       {"http://www.google.com:80/", "http://www.google.com/", true},
       {"", "http://www.google.com", false},
       {"", "", false},
       {"https://www.google.com", "http://www.google.com", false},
   };
 
   std::string label("test");
   for (size_t i = 0; i < arraysize(tests); ++i) {
     external_data_use_observer()->RegisterURLRegexes(
+        // App package name not specified in the matching rule.
         std::vector<std::string>(1, std::string()),
         std::vector<std::string>(1, tests[i].regex),
         std::vector<std::string>(1, "label"));
     EXPECT_EQ(tests[i].expect_match,
               external_data_use_observer()->Matches(GURL(tests[i].url), &label))
         << i;
 
     // Verify label matches the expected label.
     std::string expected_label = "";
     if (tests[i].expect_match)
       expected_label = "label";
 
     EXPECT_EQ(expected_label, label);
+    EXPECT_FALSE(external_data_use_observer()->MatchesAppPackageName(
+        "com.example.helloworld", &label))
+        << i;
+    // Empty package name should not match against empty package name in the
+    // matching rule.
+    EXPECT_FALSE(external_data_use_observer()->MatchesAppPackageName(
+        std::string(), &label))
+        << i;
   }
 }
 
 TEST_F(ExternalDataUseObserverTest, TwoRegex) {
   const struct {
     std::string url;
     std::string regex1;
     std::string regex2;
     bool expect_match;
   } tests[] = {
@@ skipping 19 matching lines @@
        "https://www[.]google[.]com/search.*", false},
       {"https://www.google.com/Search=test", "",
        "https://www[.]google[.]com/search.*", true},
       {"www.google.com", "http://www.google.com", "", false},
       {"www.google.com:80", "http://www.google.com", "", false},
       {"http://www.google.com:80", "http://www.google.com", "", false},
       {"", "http://www.google.com", "", false},
       {"https://www.google.com", "http://www.google.com", "", false},
   };
 
-  std::string label;
+  std::string got_label;
   for (size_t i = 0; i < arraysize(tests); ++i) {
     std::vector<std::string> url_regexes;
     url_regexes.push_back(tests[i].regex1 + "|" + tests[i].regex2);
+    const std::string label("label");
     external_data_use_observer()->RegisterURLRegexes(
-        std::vector<std::string>(url_regexes.size(), std::string()),
-        url_regexes, std::vector<std::string>(url_regexes.size(), "label"));
-    EXPECT_EQ(tests[i].expect_match,
-              external_data_use_observer()->Matches(GURL(tests[i].url), &label))
+        std::vector<std::string>(url_regexes.size(), "com.example.helloworld"),
+        url_regexes, std::vector<std::string>(url_regexes.size(), label));
+    EXPECT_EQ(tests[i].expect_match, external_data_use_observer()->Matches(
+                                         GURL(tests[i].url), &got_label))
         << i;
+    const std::string expected_label =
+        tests[i].expect_match ? label : std::string();
+    EXPECT_EQ(got_label, expected_label);
+
+    EXPECT_TRUE(external_data_use_observer()->MatchesAppPackageName(
+        "com.example.helloworld", &got_label))
+        << i;
+    EXPECT_EQ(label, got_label);
   }
 }
 
 TEST_F(ExternalDataUseObserverTest, MultipleRegex) {
   std::vector<std::string> url_regexes;
   url_regexes.push_back(
       "https?://www[.]google[.]com/#q=.*|https?://www[.]google[.]com[.]ph/"
       "#q=.*|https?://www[.]google[.]com[.]ph/[?]gws_rd=ssl#q=.*");
   external_data_use_observer()->RegisterURLRegexes(
       std::vector<std::string>(url_regexes.size(), std::string()), url_regexes,
@@ skipping 278 matching lines @@
   EXPECT_EQ(0, external_data_use_observer()
                    ->buffered_data_reports_.begin()
                    ->second.start_time.ToJavaTime());
   // Convert from seconds to milliseconds.
   EXPECT_EQ(static_cast<int64_t>(num_iterations * 1000),
             external_data_use_observer()
                 ->buffered_data_reports_.begin()
                 ->second.end_time.ToJavaTime());
 }
 
-// Tests the behavior when multiple matching rules are available.
+// Tests the behavior when multiple matching rules are available for URL and
+// package name matching.
 TEST_F(ExternalDataUseObserverTest, MultipleMatchingRules) {
   std::vector<std::string> url_regexes;
   url_regexes.push_back(
       "http://www[.]foo[.]com/#q=.*|https://www[.]foo[.]com/#q=.*");
   url_regexes.push_back(
       "http://www[.]bar[.]com/#q=.*|https://www[.]bar[.]com/#q=.*");
 
   std::vector<std::string> labels;
   const std::string label_foo("label_foo");
   const std::string label_bar("label_bar");
   labels.push_back(label_foo);
   labels.push_back(label_bar);
 
+  std::vector<std::string> app_package_names;
+  const std::string app_foo("com.example.foo");
+  const std::string app_bar("com.example.bar");
+  app_package_names.push_back(app_foo);
+  app_package_names.push_back(app_bar);
+
   external_data_use_observer()->FetchMatchingRulesDoneOnIOThread(
-      std::vector<std::string>(url_regexes.size(), std::string()), url_regexes,
-      labels);
+      app_package_names, url_regexes, labels);
   EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size());
   EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_);
   EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_);
 
   // Check |label_foo| matching rule.
   std::vector<const data_usage::DataUse*> data_use_sequence;
   data_usage::DataUse data_foo_1(
       GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
       net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_1",
       external_data_use_observer()->data_use_report_min_bytes_, 0);
@@ skipping 23 matching lines @@
   // Check |label_bar| matching rule.
   data_usage::DataUse data_bar(
       GURL("http://www.bar.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
       net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc", 0, 0);
   data_use_sequence.push_back(&data_bar);
   external_data_use_observer()->OnDataUse(data_use_sequence);
   for (const auto& it : external_data_use_observer()->buffered_data_reports_) {
     EXPECT_EQ(label_bar, it.first.label);
     EXPECT_EQ("mccmnc", it.first.mcc_mnc);
   }
+
+  // Test if labels are matched properly for app package names.
+  std::string got_label;
+  EXPECT_TRUE(
+      external_data_use_observer()->MatchesAppPackageName(app_foo, &got_label));
+  EXPECT_EQ(label_foo, got_label);
+
+  got_label = "";
+  EXPECT_TRUE(
+      external_data_use_observer()->MatchesAppPackageName(app_bar, &got_label));
+  EXPECT_EQ(label_bar, got_label);
+
+  got_label = "";
+  EXPECT_FALSE(external_data_use_observer()->MatchesAppPackageName(
+      "com.example.unmatched", &got_label));
+  EXPECT_EQ(std::string(), got_label);
+
+  EXPECT_FALSE(external_data_use_observer()->MatchesAppPackageName(
+      std::string(), &got_label));
+  EXPECT_EQ(std::string(), got_label);
 }
 
 // Tests that hash function reports distinct values. This test may fail if there
 // is a hash collision, however the chances of that happening are very low.
 TEST_F(ExternalDataUseObserverTest, HashFunction) {
   ExternalDataUseObserver::DataUseReportKeyHash hash;
 
   ExternalDataUseObserver::DataUseReportKey foo(
       "foo_label", net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
       "foo_mcc_mnc");
@@ skipping 135 matching lines @@
             external_data_use_obsever_with_variations
                 ->fetch_matching_rules_duration_);
   EXPECT_EQ(
       data_use_report_min_bytes,
       external_data_use_obsever_with_variations->data_use_report_min_bytes_);
 }
 
 }  // namespace android
 
 }  // namespace chrome