Add histograms for data usage

chrome/browser/android/data_usage/data_use_matcher.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_matcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/memory/weak_ptr.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
+#include "base/time/time.h"
 #include "chrome/browser/android/data_usage/external_data_use_observer.h"
 #include "third_party/re2/src/re2/re2.h"
 #include "url/gurl.h"
 
 namespace chrome {
 
 namespace android {
 
 DataUseMatcher::DataUseMatcher(
     const base::WeakPtr<DataUseTabModel>& data_use_tab_model,
@@ skipping 47 matching lines @@
     matching_rules_.push_back(make_scoped_ptr(new MatchingRule(
         app_package_name, std::move(pattern), labels.at(i), expiration)));
 
     removed_matching_rule_labels.erase(labels.at(i));
   }
 
   for (const std::string& label : removed_matching_rule_labels) {
     if (data_use_tab_model_)
       data_use_tab_model_->OnTrackingLabelRemoved(label);
   }
+  UMA_HISTOGRAM_COUNTS_100("DataUsage.MatchingRulesCount",

[tbansal1, 2016/01/13 18:06:52]

Can you change this to a enumerated histogram with 2 buckets:
(1) Valid (2) Invalid
Invalid would be incremented if pattern->ok() returned false above. This would
be more useful because if invalid patterns are non-zero, then that's a bad sign
(interface with external observer is broken). At the same time, count of valid
patterns would tell us that we are on the right track. wdyt?

[tbansal1, 2016/01/13 18:44:24]

Sorry, better to create 2 histograms:
DataUsage.MatchingRulesCount.Valid and
DataUsage.MatchingRulesCount.Invalid
instead of enumerated histogram.

[Raj, 2016/01/13 23:33:51]

Done.

+                           matching_rules_.size());
+
   DCHECK(io_task_runner_);
 
   // Notify |external_data_use_observer_| if it should register as a data use
   // observer.
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ExternalDataUseObserver::ShouldRegisterAsDataUseObserver,
                  external_data_use_observer_, !matching_rules_.empty()));
 }
 
 bool DataUseMatcher::MatchesURL(const GURL& url, std::string* label) const {
   const base::TimeTicks now_ticks = tick_clock_->NowTicks();
   DCHECK(thread_checker_.CalledOnValidThread());
   *label = "";
 
   if (!url.is_valid() || url.is_empty())
     return false;
 
   for (const auto& matching_rule : matching_rules_) {
     if (matching_rule->expiration() <= now_ticks)
       continue;  // skip expired matching rules.
-    if (re2::RE2::FullMatch(url.spec(), *(matching_rule->pattern()))) {
+    base::TimeTicks begin = base::TimeTicks::Now();

[tbansal1, 2016/01/13 18:06:52]

This might be more useful if it records the duration against all regexes (that's
what we want to minimize). So, may be move after the for loop.

[Raj, 2016/01/13 23:33:51]

If there are multiple regexes, the total duration is probably going to be in its
multiple, and we won't be able to compare the performance. If we report for each
regex, we would find distinct difference for bad regexes and try to finetune
them. WDYT ?

+    bool match = re2::RE2::FullMatch(url.spec(), *(matching_rule->pattern()));
+    UMA_HISTOGRAM_TIMES("DataUsage.Perf.URLRegexMatchDuration",
+                        base::TimeTicks::Now() - begin);
+    if (match) {
       *label = matching_rule->label();
       return true;
     }
   }
 
   return false;
 }
 
 bool DataUseMatcher::MatchesAppPackageName(const std::string& app_package_name,
                                            std::string* label) const {
@@ skipping 73 matching lines @@
   return label_;
 }
 
 const base::TimeTicks& DataUseMatcher::MatchingRule::expiration() const {
   return expiration_;
 }
 
 }  // namespace android
 
 }  // namespace chrome