content/browser/android/content_view_statics.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <jni.h>
   6 #include <vector>
   7
   8 #include "base/android/jni_android.h"
   9 #include "base/android/jni_string.h"
  10 #include "base/android/scoped_java_ref.h"
  11 #include "base/basictypes.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/logging.h"
  14 #include "content/browser/android/content_view_statics.h"
  15 #include "content/common/android/address_parser.h"
  16 #include "content/common/view_messages.h"
  17 #include "content/public/browser/render_process_host.h"
  18 #include "content/public/browser/render_process_host_observer.h"
  19 #include "jni/ContentViewStatics_jni.h"
  20
  21 using base::android::ConvertJavaStringToUTF16;
  22 using base::android::ConvertUTF16ToJavaString;
  23
  24 namespace {
  25
  26 // TODO(pliard): http://crbug.com/235909. Move WebKit shared timer toggling
  27 // functionality out of ContentViewStatistics and not be build on top of
  28 // blink::Platform::SuspendSharedTimer.
  29 // TODO(pliard): http://crbug.com/235912. Add unit tests for WebKit shared timer
  30 // toggling.
  31
  32 // This tracks the renderer processes that received a suspend request. It's
  33 // important on resume to only resume the renderer processes that were actually
  34 // suspended as opposed to all the current renderer processes because the
  35 // suspend calls are refcounted within WebKitPlatformSupport and it expects a
  36 // perfectly matched number of resume calls.
  37 // Note that this class is only accessed from the UI thread.
  38 class SuspendedProcessWatcher : public content::RenderProcessHostObserver {
  39  public:
  40
  41   // If the process crashes, stop watching the corresponding RenderProcessHost
  42   // and ensure it doesn't get over-resumed.
  43   virtual void RenderProcessExited(content::RenderProcessHost* host,
  44                                    base::ProcessHandle handle,
  45                                    base::TerminationStatus status,
  46                                    int exit_code) OVERRIDE {
  47     StopWatching(host);
  48   }
  49
  50   virtual void RenderProcessHostDestroyed(
  51       content::RenderProcessHost* host) OVERRIDE {
  52     StopWatching(host);
  53   }
  54
  55   // Suspends timers in all current render processes.
  56   void SuspendWebKitSharedTimers() {
  57     DCHECK(suspended_processes_.empty());
  58
  59     for (content::RenderProcessHost::iterator i(
  60             content::RenderProcessHost::AllHostsIterator());
  61          !i.IsAtEnd(); i.Advance()) {
  62       content::RenderProcessHost* host = i.GetCurrentValue();
  63       host->AddObserver(this);
  64       host->Send(new ViewMsg_SetWebKitSharedTimersSuspended(true));
  65       suspended_processes_.push_back(host->GetID());
  66     }
  67   }
  68
  69   // Resumes timers in processes that were previously stopped.
  70   void ResumeWebkitSharedTimers() {
  71     for (std::vector<int>::const_iterator it = suspended_processes_.begin();
  72          it != suspended_processes_.end(); ++it) {
  73       content::RenderProcessHost* host =
  74           content::RenderProcessHost::FromID(*it);
  75       DCHECK(host);
  76       host->RemoveObserver(this);
  77       host->Send(new ViewMsg_SetWebKitSharedTimersSuspended(false));
  78     }
  79     suspended_processes_.clear();
  80   }
  81
  82  private:
  83   void StopWatching(content::RenderProcessHost* host) {
  84     std::vector<int>::iterator pos = std::find(suspended_processes_.begin(),
  85                                                suspended_processes_.end(),
  86                                                host->GetID());
  87     DCHECK_NE(pos, suspended_processes_.end());
  88     host->RemoveObserver(this);
  89     suspended_processes_.erase(pos);
  90   }
  91
  92   std::vector<int /* RenderProcessHost id */> suspended_processes_;
  93 };
  94
  95 base::LazyInstance<SuspendedProcessWatcher> g_suspended_processes_watcher =
  96     LAZY_INSTANCE_INITIALIZER;
  97
  98 }  // namespace
  99
 100 // Returns the first substring consisting of the address of a physical location.
 101 static jstring FindAddress(JNIEnv* env, jclass clazz, jstring addr) {
 102   base::string16 content_16 = ConvertJavaStringToUTF16(env, addr);
 103   base::string16 result_16;
 104   if (content::address_parser::FindAddress(content_16, &result_16))
 105     return ConvertUTF16ToJavaString(env, result_16).Release();
 106   return NULL;
 107 }
 108
 109 static void SetWebKitSharedTimersSuspended(JNIEnv* env,
 110                                            jclass obj,
 111                                            jboolean suspend) {
 112   if (suspend) {
 113     g_suspended_processes_watcher.Pointer()->SuspendWebKitSharedTimers();
 114   } else {
 115     g_suspended_processes_watcher.Pointer()->ResumeWebkitSharedTimers();
 116   }
 117 }
 118
 119 namespace content {
 120
 121 bool RegisterWebViewStatics(JNIEnv* env) {
 122   return RegisterNativesImpl(env);
 123 }
 124
 125 }  // namespace content