Add external data use observer

chrome/browser/android/datausage/external_data_use_observer_android.cc

Index: chrome/browser/android/datausage/external_data_use_observer_android.cc
diff --git a/chrome/browser/android/datausage/external_data_use_observer_android.cc b/chrome/browser/android/datausage/external_data_use_observer_android.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dc6d6784275a36e21bef2a493eeee6f3c342486a
--- /dev/null
+++ b/chrome/browser/android/datausage/external_data_use_observer_android.cc
@@ -0,0 +1,110 @@
+// 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/datausage/external_data_use_observer_android.h"
+
+#include <string>
+
+#include "base/android/jni_string.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
+#include "jni/ExternalDataUseObserverAndroid_jni.h"
+#include "third_party/re2/re2/re2.h"
+#include "url/gurl.h"
+
+using base::android::ConvertUTF8ToJavaString;
+
+namespace chrome {
+
+namespace android {
+
+ExternalDataUseObserverAndroid::ExternalDataUseObserverAndroid(
+    data_usage::DataUseAggregator* data_use_aggregator)
+    : data_use_aggregator_(data_use_aggregator) {
+  if (!data_use_aggregator_)
+    return;
+  JNIEnv* env = base::android::AttachCurrentThread();
+  DCHECK(j_external_data_use_observer_.is_null());
+  j_external_data_use_observer_.Reset(
+      Java_ExternalDataUseObserverAndroid_create(
+          env, base::android::GetApplicationContext(),
+          reinterpret_cast<intptr_t>(this)));
+  DCHECK(!j_external_data_use_observer_.is_null());
+}
+
+ExternalDataUseObserverAndroid::~ExternalDataUseObserverAndroid() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!data_use_aggregator_)
+    return;
+  if (url_regexes_.size() > 0)
+    data_use_aggregator_->RemoveObserver(this);
+}
+
+bool ExternalDataUseObserverAndroid::Matches(const GURL& gurl) const {
+  if (!gurl.is_valid() || gurl.is_empty())
+    return false;
+
+  std::string gurl_spec = gurl.spec();

[sclittle, 2015/10/09 22:59:28]

nit: To avoid the unnecessary string allocation, change to:

const std::string& gurl_spec = gurl.spec();

[tbansal1, 2015/10/12 16:47:36]

Done.

+
+  for (const std::string& url_regex : url_regexes_) {
+    if (re2::RE2::FullMatch(gurl_spec, url_regex))
+      return true;
+  }
+
+  return false;
+}
+
+void ExternalDataUseObserverAndroid::OnDataUse(
+    const std::vector<data_usage::DataUse>& data_use_sequence) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!j_external_data_use_observer_.is_null());
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+
+  for (const auto& data_use : data_use_sequence) {
+    if (!Matches(data_use.url))
+      continue;
+
+    std::string tag = "";  // data_use.tab_id;
+    int64_t bytes_downloaded = data_use.rx_bytes;
+    int64_t bytes_uploaded = data_use.tx_bytes;
+    Java_ExternalDataUseObserverAndroid_onDataUse(

[sclittle, 2015/10/09 22:59:28]

Hmmm - as the aggregator exists right now, this will call into JNI on every read
and write and block the request processing.

Even once the DataUseAggregator starts buffering and amortizing DataUse, it
could still happen very often. Could the Java ExternalDataUseObserver specify
some buffering parameters or something for this C++ observer to follow? Like,
perhaps to report once every K bytes or something.

Also, could it be possible to run the JNI stuff on a different thread or
something, so that it doesn't block request processing? Or do we want it to be
possible for the JNI stuff to be able to block request processing?

[tbansal1, 2015/10/12 16:47:35]

Added TODO for buffering. Plan is to report every K bytes.

+        env, j_external_data_use_observer_.obj(),
+        ConvertUTF8ToJavaString(env, tag).obj(), bytes_downloaded,
+        bytes_uploaded);
+  }
+}
+
+void ExternalDataUseObserverAndroid::RegisterURLRegexes(
+    const std::vector<std::string>& url_regexes) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  bool registered_as_observer = url_regexes_.size() > 0;
+  if (!registered_as_observer && url_regexes.size() > 0) {
+    registered_as_observer = true;
+    data_use_aggregator_->AddObserver(this);
+  }
+
+  url_regexes_.clear();
+
+  for (const std::string& url_regex : url_regexes) {
+    if (url_regex.empty())
+      continue;
+    base::StringPiece url_regex_stringpiece(url_regex);
+    url_regexes_.push_back(ToLowerASCII(url_regex_stringpiece));
+  }
+
+  // Unregister as an observer if no regular expressions were received.
+  if (url_regexes_.size() == 0 && registered_as_observer)
+    data_use_aggregator_->RemoveObserver(this);
+}
+
+bool RegisterExternalDataUseObserverAndroid(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+}  // namespace android
+
+}  // namespace chrome