Add connectivity check for Android feedback.

chrome/browser/android/feedback/connectivity_checker.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/feedback/connectivity_checker.h"
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_string.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/message_loop/message_loop.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_android.h"
+#include "jni/ConnectivityChecker_jni.h"
+#include "net/base/load_flags.h"
+#include "net/http/http_status_code.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_status.h"
+#include "url/gurl.h"
+
+namespace chrome {
+namespace android {
+
+namespace {
+
+void ExecuteCallback(jobject callback, bool connected) {
+  Java_ConnectivityChecker_executeCallback(base::android::AttachCurrentThread(),
+                                           callback, connected);
+}
+
+void ExecuteCallbackFromRef(
+    base::android::ScopedJavaGlobalRef<jobject>* callback,
+    bool connected) {
+  ExecuteCallback(callback->obj(), connected);
+}
+
+void PostCallback(JNIEnv* env, jobject j_callback, bool connected) {
+  base::android::ScopedJavaGlobalRef<jobject>* callback =
+      new base::android::ScopedJavaGlobalRef<jobject>();

[cjhopman, 2015/05/07 00:09:09]

You can just pass the j_callback to the constructor here. I'd probably even just
inline it in the PostTask call below

[nyquist, 2015/05/07 05:35:46]

I for some reason could not get that to work. Happy to change this if you have a
tips for how to get it to work though, because I get the following error when
doing that:
n file included from
../../chrome/browser/android/feedback/connectivity_checker.cc:5:
In file included from
../../chrome/browser/android/feedback/connectivity_checker.h:8:
In file included from ../../base/android/jni_android.h:13:
../../base/android/scoped_java_ref.h:196:28: error: member reference type
'_jobject *const' is a pointer; maybe you meant to use '->'?
    this->Reset(NULL, other.obj());
                      ~~~~~^
                           ->
../../base/android/scoped_java_ref.h:183:11: note: in instantiation of function
template specialization 'base::android::ScopedJavaGlobalRef<_jobject
*>::Reset<_jobject *>' requested here
    this->Reset(other);
          ^
../../chrome/browser/android/feedback/connectivity_checker.cc:42:11: note: in
instantiation of function template specialization
'base::android::ScopedJavaGlobalRef<_jobject *>::ScopedJavaGlobalRef<_jobject
*>' requested here
      new base::android::ScopedJavaGlobalRef<jobject>(j_callback);
          ^
In file included from
../../chrome/browser/android/feedback/connectivity_checker.cc:5:
In file included from
../../chrome/browser/android/feedback/connectivity_checker.h:8:
In file included from ../../base/android/jni_android.h:13:
../../base/android/scoped_java_ref.h:196:29: error: no member named 'obj' in
'_jobject'
    this->Reset(NULL, other.obj());
                      ~~~~~ ^
2 errors generated.
ninja: build stopped: subcommand failed.

[cjhopman, 2015/05/08 18:58:39]

I'd say you should just add the appropriate constructor to
ScopedJavaGlobalRef... it's silly that it doesn't have it.

But, up to you.

[nyquist, 2015/05/12 00:42:30]

Done.

+  callback->Reset(env, j_callback);
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&ExecuteCallbackFromRef, base::Owned(callback), connected));
+}
+
+// A utility class for checking if the device is currently connected to the
+// Internet.
+class ConnectivityChecker : public net::URLFetcherDelegate {
+ public:
+  ConnectivityChecker(Profile* profile,
+                      const GURL& url,
+                      const base::TimeDelta& timeout,
+                      const base::android::JavaRef<jobject>& java_callback);
+
+  // Kicks off the asynchronous connectivity check. When the request has
+  // completed, |this| is deleted.
+  void StartAsyncCheck();
+
+  // net::URLFetcherDelegate implementation:
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
+
+  // Cancels the URLFetcher, and triggers the callback with a negative result.
+  void Cancel();
+
+ private:
+  // The context in which the connectivity check is performed.
+  net::URLRequestContextGetter* request_context_;
+
+  // The URL to connect to.
+  const GURL& url_;
+
+  // How long to wait for a response before giving up.
+  const base::TimeDelta& timeout_;
+
+  // Holds the Java object which will get the callback with the result.
+  base::android::ScopedJavaGlobalRef<jobject> java_callback_;
+
+  // The URLFetcher that executes the connectivity check.
+  scoped_ptr<net::URLFetcher> url_fetcher_;
+
+  scoped_ptr<base::OneShotTimer<ConnectivityChecker>> expiration_timer_;
+};
+
+void ConnectivityChecker::OnURLFetchComplete(const net::URLFetcher* source) {
+  DCHECK_EQ(url_fetcher_.get(), source);
+
+  net::URLRequestStatus status = source->GetStatus();
+  int response_code = source->GetResponseCode();
+
+  bool connected = status.is_success() && response_code == net::HTTP_NO_CONTENT;
+  ExecuteCallback(java_callback_.obj(), connected);
+
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);

[cjhopman, 2015/05/07 00:09:10]

There's a race here that could cause a double delete: basically if the url
fetcher and the timeout happen at essentially the same time (fetcher first), two
delete tasks could be posted. In that case the callback would actually be called
twice, also.

[nyquist, 2015/05/07 05:35:46]

Doh! Thanks.

Added a boolean to track the destruction. Everything happens on the same thread,
so there shouldn't be concurrency issues with that.

+}
+
+ConnectivityChecker::ConnectivityChecker(
+    Profile* profile,
+    const GURL& url,
+    const base::TimeDelta& timeout,
+    const base::android::JavaRef<jobject>& java_callback)
+    : request_context_(profile->GetRequestContext()),
+      url_(url),
+      timeout_(timeout),
+      java_callback_(java_callback) {
+}
+
+void ConnectivityChecker::StartAsyncCheck() {
+  url_fetcher_ =
+      net::URLFetcher::Create(url_, net::URLFetcher::GET, this).Pass();
+  url_fetcher_->SetRequestContext(request_context_);
+  url_fetcher_->SetStopOnRedirect(true);
+  url_fetcher_->SetAutomaticallyRetryOn5xx(false);
+  url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(0);
+  url_fetcher_->SetLoadFlags(net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE |
+                             net::LOAD_DO_NOT_SAVE_COOKIES |
+                             net::LOAD_DO_NOT_SEND_COOKIES |
+                             net::LOAD_DO_NOT_SEND_AUTH_DATA);
+  url_fetcher_->Start();
+  expiration_timer_.reset(new base::OneShotTimer<ConnectivityChecker>());
+  expiration_timer_->Start(FROM_HERE, timeout_, this,
+                           &ConnectivityChecker::Cancel);
+}
+
+void ConnectivityChecker::Cancel() {
+  url_fetcher_.reset();
+  ExecuteCallback(java_callback_.obj(), false);
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+}
+
+}  // namespace
+
+void CheckConnectivity(JNIEnv* env,
+                       jclass clazz,
+                       jobject j_profile,
+                       jstring j_url,
+                       jlong j_timeout_ms,
+                       jobject j_callback) {
+  Profile* profile = ProfileAndroid::FromProfileAndroid(j_profile);
+  if (!profile) {
+    PostCallback(env, j_callback, false);
+    return;
+  }
+  GURL url(base::android::ConvertJavaStringToUTF8(env, j_url));
+  if (!url.is_valid()) {
+    PostCallback(env, j_callback, false);
+    return;
+  }
+
+  // This object will be deleted when the connectivity check has completed.
+  ConnectivityChecker* connectivity_checker = new ConnectivityChecker(
+      profile, url, base::TimeDelta::FromMilliseconds(j_timeout_ms),
+      base::android::ScopedJavaLocalRef<jobject>(env, j_callback));
+  connectivity_checker->StartAsyncCheck();
+}
+
+bool RegisterConnectivityChecker(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+}  // namespace android
+}  // namespace chrome