Change the function name to match downstream

chrome/browser/android/data_usage/external_data_use_observer.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 <utility>
 
 #include "base/android/jni_string.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 121 matching lines @@
 }
 
 void ExternalDataUseObserver::FetchMatchingRulesOnUIThread() const {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   DCHECK(!j_external_data_use_observer_.is_null());
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_ExternalDataUseObserver_fetchMatchingRules(
       env, j_external_data_use_observer_.obj());
 }
 
-void ExternalDataUseObserver::FetchMatchingRulesCallback(
+void ExternalDataUseObserver::FetchMatchingRulesDone(
     JNIEnv* env,
     jobject obj,
     const base::android::JavaParamRef<jobjectArray>& app_package_name,
     const base::android::JavaParamRef<jobjectArray>& domain_path_regex,
     const base::android::JavaParamRef<jobjectArray>& label) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
   // Convert to native objects.
   std::vector<std::string> app_package_name_native;
   std::vector<std::string> domain_path_regex_native;
   std::vector<std::string> label_native;
 
   if (app_package_name && domain_path_regex && label) {
     base::android::AppendJavaStringArrayToStringVector(
         env, app_package_name, &app_package_name_native);
     base::android::AppendJavaStringArrayToStringVector(
         env, domain_path_regex, &domain_path_regex_native);
     base::android::AppendJavaStringArrayToStringVector(env, label,
                                                        &label_native);
   }
 
   io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&ExternalDataUseObserver::FetchMatchingRulesCallbackOnIOThread,
+      base::Bind(&ExternalDataUseObserver::FetchMatchingRulesDoneOnIOThread,
                  GetIOWeakPtr(), app_package_name_native,
                  domain_path_regex_native, label_native));
 }
 
-void ExternalDataUseObserver::FetchMatchingRulesCallbackOnIOThread(
+void ExternalDataUseObserver::FetchMatchingRulesDoneOnIOThread(
     const std::vector<std::string>& app_package_name,
     const std::vector<std::string>& domain_path_regex,
     const std::vector<std::string>& label) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   RegisterURLRegexes(app_package_name, domain_path_regex, label);
   matching_rules_fetch_pending_ = false;
   // Process buffered reports.
 }
 
@@ skipping 198 matching lines @@
     const re2::RE2* pattern = matching_rules_[i]->pattern();
     if (re2::RE2::FullMatch(gurl.spec(), *pattern)) {
       *label = matching_rules_[i]->label();
       return true;
     }
   }
 
   return false;
 }
 
+ExternalDataUseObserver::DataUseReportKey::DataUseReportKey(
+    const std::string& label,
+    net::NetworkChangeNotifier::ConnectionType connection_type,
+    const std::string& mcc_mnc)
+    : label(label), connection_type(connection_type), mcc_mnc(mcc_mnc) {}
+
+bool ExternalDataUseObserver::DataUseReportKey::operator==(
+    const DataUseReportKey& other) const {
+  return label == other.label && connection_type == other.connection_type &&
+         mcc_mnc == other.mcc_mnc;
+}
+
+ExternalDataUseObserver::DataUseReport::DataUseReport(
+    const base::Time& start_time,
+    const base::Time& end_time,
+    int64_t bytes_downloaded,
+    int64_t bytes_uploaded)
+    : start_time(start_time),
+      end_time(end_time),
+      bytes_downloaded(bytes_downloaded),
+      bytes_uploaded(bytes_uploaded) {}
+
+size_t ExternalDataUseObserver::DataUseReportKeyHash::operator()(
+    const DataUseReportKey& k) const {
+  //  The hash is computed by hashing individual variables and combining them
+  //  using prime numbers. Prime numbers are used for multiplication because the
+  //  number of buckets used by map is always an even number. Using a prime
+  //  number ensures that for two different DataUseReportKey objects (say |j|
+  //  and |k|), if the hash value of |k.label| is equal to hash value of
+  //  |j.mcc_mnc|, then |j| and |k| map to different buckets. Large prime
+  //  numbers are used so that hash value is spread over a larger range.
+  std::hash<std::string> hash_function;
+  size_t hash = 1;
+  hash = hash * 23 + hash_function(k.label);
+  hash = hash * 43 + k.connection_type;
+  hash = hash * 83 + hash_function(k.mcc_mnc);
+  return hash;
+}
+
 ExternalDataUseObserver::MatchingRule::MatchingRule(
     const std::string& app_package_name,
     scoped_ptr<re2::RE2> pattern,
     const std::string& label)
     : app_package_name_(app_package_name),
       pattern_(pattern.Pass()),
       label_(label) {}
 
 ExternalDataUseObserver::MatchingRule::~MatchingRule() {}
 
 const re2::RE2* ExternalDataUseObserver::MatchingRule::pattern() const {
   return pattern_.get();
 }
 
 const std::string& ExternalDataUseObserver::MatchingRule::label() const {
   return label_;
 }
 
 bool RegisterExternalDataUseObserver(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace android
 
 }  // namespace chrome