Add a mechanism to pause and resume geolocation requests.

content/browser/android/content_view_core_impl.cc

 // Copyright 2012 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 "content/browser/android/content_view_core_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "content/browser/android/interstitial_page_delegate_android.h"
 #include "content/browser/android/load_url_params.h"
 #include "content/browser/android/touch_point.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
@@ skipping 74 matching lines @@
 
 ScopedJavaLocalRef<jobject> CreateJavaRect(
     JNIEnv* env,
     const gfx::Rect& rect) {
   return ScopedJavaLocalRef<jobject>(
       Java_ContentViewCore_createRect(env,
                                       static_cast<int>(rect.x()),
                                       static_cast<int>(rect.y()),
                                       static_cast<int>(rect.right()),
                                       static_cast<int>(rect.bottom())));
-};
+}
+
+void IsGeolocationActiveForTestingOnIOThread(
+    scoped_refptr<GeolocationDispatcherHost> d,
+    base::WaitableEvent* completion,
+    bool* result) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  *result = d->IsGeolocationActive();
+  completion->Signal();
+}
+
 }  // namespace
 
 // Enables a callback when the underlying WebContents is destroyed, to enable
 // nulling the back-pointer.
 class ContentViewCoreImpl::ContentViewUserData
     : public base::SupportsUserData::Data {
  public:
   explicit ContentViewUserData(ContentViewCoreImpl* content_view_core)
       : content_view_core_(content_view_core) {
   }
@@ skipping 45 matching lines @@
     : WebContentsObserver(web_contents),
       java_ref_(env, obj),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       root_layer_(cc::Layer::Create()),
       vsync_interval_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros)),
       expected_browser_composite_time_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros * kDefaultBrowserCompositeVSyncFraction)),
       view_android_(view_android),
       window_android_(window_android),
-      device_orientation_(0) {
+      device_orientation_(0),
+      geolocation_needs_pause_(false) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
   // TODO(leandrogracia): make use of the hardware_accelerated argument.
 
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   dpi_scale_ = display.device_scale_factor();
 
   // Currently, the only use case we have for overriding a user agent involves
@@ skipping 64 matching lines @@
       if (new_pid != old_pid) {
         // Notify the Java side of the change of the current renderer process.
         JNIEnv* env = AttachCurrentThread();
         ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
         if (!obj.is_null()) {
           Java_ContentViewCore_onRenderProcessSwap(
               env, obj.obj(), old_pid, new_pid);
         }
       }
       SetFocusInternal(HasFocus());
+      if (geolocation_needs_pause_)
+        PauseOrResumeGeolocation(true);
       break;
     }
     case NOTIFICATION_RENDERER_PROCESS_CREATED: {
       // Notify the Java side of the current renderer process.
       RenderProcessHost* source_process_host =
           Source<RenderProcessHost>(source).ptr();
       RenderProcessHost* current_process_host =
           web_contents_->GetRenderViewHost()->GetProcess();
 
       if (source_process_host == current_process_host) {
@@ skipping 65 matching lines @@
   GetWebContents()->WasHidden();
   PauseVideo();
 }
 
 void ContentViewCoreImpl::PauseVideo() {
   RenderViewHost* host = web_contents_->GetRenderViewHost();
   if (host)
     host->Send(new ViewMsg_PauseVideo(host->GetRoutingID()));
 }
 
+void ContentViewCoreImpl::PauseOrResumeGeolocation(bool should_pause) {
+  geolocation_needs_pause_ = should_pause;
+  RenderViewHostImpl* rvh =
+      static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost());
+  if (rvh) {
+    scoped_refptr<GeolocationDispatcherHost> geolocation_dispatcher =
+        static_cast<RenderProcessHostImpl*>(
+            web_contents_->GetRenderProcessHost())->
+            geolocation_dispatcher_host();
+    if (geolocation_dispatcher.get()) {
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(&GeolocationDispatcherHost::PauseOrResume,
+          geolocation_dispatcher,
+          rvh->GetRoutingID(),
+          should_pause));
+      geolocation_needs_pause_ = false;
+    }
+  }
+}
+
 void ContentViewCoreImpl::OnTabCrashed() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_ContentViewCore_resetVSyncNotification(env, obj.obj());
 }
 
 // All positions and sizes are in CSS pixels.
 // Note that viewport_width/height is a best effort based.
@@ skipping 1264 matching lines @@
 void ContentViewCoreImpl::SendOrientationChangeEventInternal() {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (rwhv)
     rwhv->UpdateScreenInfo(rwhv->GetNativeView());
 
   RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(
       web_contents_->GetRenderViewHost());
   rvhi->SendOrientationChangeEvent(device_orientation_);
 }
 
+bool ContentViewCoreImpl::IsGeolocationActiveForTesting(JNIEnv* env,
+                                                        jobject obj) {
+  RenderViewHostImpl* rvh =
+      static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost());
+  if (rvh) {
+    scoped_refptr<GeolocationDispatcherHost> geolocation_dispatcher =
+        static_cast<RenderProcessHostImpl*>(
+            web_contents_->GetRenderProcessHost())->
+            geolocation_dispatcher_host();
+    if (geolocation_dispatcher.get()) {
+      bool result = false;
+      base::WaitableEvent completion(false, false);
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(IsGeolocationActiveForTestingOnIOThread,
+          geolocation_dispatcher, &completion, &result));
+      completion.Wait();
+      return result;
+    }
+  }
+
+  return false;
+}
+
 // This is called for each ContentView.
 jlong Init(JNIEnv* env, jobject obj,
            jboolean hardware_accelerated,
            jlong native_web_contents,
            jlong view_android,
            jlong window_android) {
   ContentViewCoreImpl* view = new ContentViewCoreImpl(
       env, obj, hardware_accelerated,
       reinterpret_cast<WebContents*>(native_web_contents),
       reinterpret_cast<ui::ViewAndroid*>(view_android),
       reinterpret_cast<ui::WindowAndroid*>(window_android));
   return reinterpret_cast<intptr_t>(view);
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content