ExternalDataUseObserver JNI integration

chrome/browser/android/data_usage/external_data_use_observer.h

 // 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.
 
 #ifndef CHROME_BROWSER_ANDROID_DATA_USAGE_EXTERNAL_DATA_USE_OBSERVER_H_
 #define CHROME_BROWSER_ANDROID_DATA_USAGE_EXTERNAL_DATA_USE_OBSERVER_H_
 
 #include <jni.h>
 #include <stdint.h>
 
 #include <string>
-#include <unordered_map>
 #include <vector>
 
 #include "base/android/jni_array.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "components/data_usage/core/data_use_aggregator.h"
@@ skipping 46 matching lines @@
       const base::android::JavaParamRef<jobjectArray>& app_package_name,
       const base::android::JavaParamRef<jobjectArray>& domain_path_regex,
       const base::android::JavaParamRef<jobjectArray>& label);
 
   // Called by Java when the reporting of data usage has finished.  This may be
   // called on a different thread. |success| is true if the request was
   // successfully submitted to the external data use observer by Java. Must be
   // called on UI thread.
   void OnReportDataUseDone(JNIEnv* env, jobject obj, bool success);
 
+  // Returns the external data use observer field trial name.
+  const std::string GetExternalDataUseObserverFieldTrialName() const;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, SingleRegex);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, TwoRegex);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, MultipleRegex);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, ChangeRegex);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest,
                            AtMostOneDataUseSubmitRequest);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, MultipleMatchingRules);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, ReportsMergedCorrectly);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest,
                            TimestampsMergedCorrectly);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, HashFunction);
   FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, BufferSize);
+  FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest,
+                           PeriodicFetchMatchingRules);
+  FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, BufferDataUseReports);
+  FRIEND_TEST_ALL_PREFIXES(ExternalDataUseObserverTest, Variations);
 
   // DataUseReportKey is a unique identifier for a data use report.
   struct 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) {}
 
     DataUseReportKey(const DataUseReportKey& other)

[sclittle, 2015/11/07 02:05:32]

nit: This copy constructor is unnecessary, since it's the same as the default
copy constructor.

[tbansal1, 2015/11/07 02:33:03]

Done.

         : label(other.label),
           connection_type(other.connection_type),
           mcc_mnc(other.mcc_mnc) {}
 
     bool operator==(const DataUseReportKey& other) const {
       return (label == other.label &&
               connection_type == other.connection_type &&
               mcc_mnc == other.mcc_mnc);
     }
 
@@ skipping 60 matching lines @@
     size_t operator()(const DataUseReportKey& k) const {
       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;
     }
   };
 
-  typedef std::unordered_map<DataUseReportKey,
-                             DataUseReport,
-                             DataUseReportKeyHash> DataUseReports;
+  typedef base::hash_map<DataUseReportKey, DataUseReport, DataUseReportKeyHash>
+      DataUseReports;
 
   // Stores the matching rules.
   class MatchingRule {
    public:
     MatchingRule(const std::string& app_package_name,
                  scoped_ptr<re2::RE2> pattern,
                  const std::string& label);
     ~MatchingRule();
 
     const re2::RE2* pattern() const;
@@ skipping 107 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // |ui_task_runner_| is used to call Java code on UI thread. This ensures
   // that Java code is safely called only on a single thread, and eliminates
   // the need for locks in Java.
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
   // Time when the data use reports were last received from DataUseAggregator.
   base::Time previous_report_time_;
 
+  // Time when the matching rules were last fetched.
+  base::TimeTicks last_matching_rules_fetch_time_;
+
+  // Total number of bytes transmitted or received across all the buffered
+  // reports.
+  int64_t total_bytes_buffered_;
+
+  // Duration after which matching rules are periodically fetched.
+  const base::TimeDelta fetch_matching_rules_duration_;
+
+  // Minimum number of bytes that should be buffered before a data use report is
+  // submitted.
+  const int64_t data_use_report_min_bytes_;
+
   base::ThreadChecker thread_checker_;
 
   // |io_weak_factory_| and |ui_weak_factory_| are used for posting tasks on the
   // IO and UI thread, respectively.
   base::WeakPtrFactory<ExternalDataUseObserver> io_weak_factory_;
   base::WeakPtrFactory<ExternalDataUseObserver> ui_weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalDataUseObserver);
 };
 
 bool RegisterExternalDataUseObserver(JNIEnv* env);
 
 }  // namespace android
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_ANDROID_DATA_USAGE_EXTERNAL_DATA_USE_OBSERVER_H_