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>
 
@@ skipping 62 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;

[sclittle, 2015/11/06 23:42:50]

Make this a static constant.

[tbansal1, 2015/11/07 01:32:43]

This function would be used by Raj to control other params in his classes (e.g.,
how many tabs to maintain the memory etc.)

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

Could it just be a publicly visible static constant then?

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

Done.

+
  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)
         : label(other.label),
@@ skipping 17 matching lines @@
     // mcc_mnc operator of the provider of the SIM as obtained from
     // TelephonyManager#getNetworkOperator() Java API in Android.
     const std::string mcc_mnc;
   };
 
   // DataUseReport is paired with a  DataUseReportKey object. DataUseReport
   // contains the bytes send/received during a specific interval. Only the bytes
   // from the data use reports that have the |label|, |connection_type|, and
   // |mcc_mnc| specified in the corresponding DataUseReportKey object are
   // counted in the DataUseReport.
   struct DataUseReport {

[sclittle, 2015/11/06 23:42:50]

For a future CL: This DataUseReport stuff should really be moved out to its own
separate files, and the implementations of all the constructors/methods should
be in the .cc file, not the header file.

[tbansal1, 2015/11/07 01:32:43]

Agree with moving the implementation to .cc but why is it useful to move them to
separate files since the inner classes are only used here.

http://www.chromium.org/developers/coding-style/cpp-dos-and-donts#TOC-Move-in....

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

Good point, it might make sense to move them to separate files later if they get
complicated though.

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

Acknowledged.

     // |start_time| and |end_time| are the start and end timestamps (in UTC
     // since the standard Java epoch of 1970-01-01 00:00:00) of the interval
     // that this data report covers. |bytes_downloaded| and |bytes_uploaded| are
     // the total bytes received and send during this interval.
     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),
@@ skipping 31 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,

[sclittle, 2015/11/06 23:42:50]

Change this to use base::hash_map from
https://code.google.com/p/chromium/codesearch#chromium/src/base/containers/ha...

Chromium code isn't allowed to use C++11 STL containers like unordered_map. See
https://chromium-cpp.appspot.com/

I'm surprised this compiles at all - last time I checked, Android was one of the
platforms that didn't support C++11 STL coolness.

[tbansal1, 2015/11/07 01:32:43]

Interesting. Fixed it.

                              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();
@@ skipping 11 matching lines @@
     // Opaque label that uniquely identifies this matching rule.
     const std::string label_;
 
     DISALLOW_COPY_AND_ASSIGN(MatchingRule);
   };
 
   // Maximum buffer size. If an entry needs to be added to the buffer that has
   // size |kMaxBufferSize|, then the oldest entry will be removed.
   static const size_t kMaxBufferSize = 100;
 
+  // Populates various parameters from the values specified in the field trial.
+  void PopulateFieldTrialParams();

[sclittle, 2015/11/06 23:42:50]

Could this just be a few anonymous functions in the .cc file instead of a
method?

[tbansal1, 2015/11/07 01:32:43]

Done.

+
   // Creates Java object. Must be called on the UI thread.
   void CreateJavaObjectOnUIThread();
 
   // data_usage::DataUseAggregator::Observer implementation:
   void OnDataUse(const std::vector<const data_usage::DataUse*>&
                      data_use_sequence) override;
 
   // Fetches matching rules from Java. Must be called on the UI thread. Returns
   // result asynchronously on UI thread via FetchMatchingRulesCallback.
   void FetchMatchingRulesOnUIThread() const;
@@ skipping 78 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.
+  base::TimeDelta fetch_matching_rules_duration_;
+
+  // Minimum number of bytes that should be buffered before a data use report is
+  // submitted.
+  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_