Fix bug causing blank pages on resume of Chrome for Android.

content/browser/android/content_view_statics.cc

 // Copyright (c) 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 <jni.h>
 #include <vector>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "content/browser/android/content_view_statics.h"
 #include "content/common/android/address_parser.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_process_host_observer.h"
 #include "jni/ContentViewStatics_jni.h"
 
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertUTF16ToJavaString;
 
 namespace {
 
 // TODO(pliard): http://crbug.com/235909. Move WebKit shared timer toggling
 // functionality out of ContentViewStatistics and not be build on top of
 // blink::Platform::SuspendSharedTimer.
 // TODO(pliard): http://crbug.com/235912. Add unit tests for WebKit shared timer
 // toggling.
 
 // This tracks the renderer processes that received a suspend request. It's
 // important on resume to only resume the renderer processes that were actually
 // suspended as opposed to all the current renderer processes because the
 // suspend calls are refcounted within WebKitPlatformSupport and it expects a
 // perfectly matched number of resume calls.
 // Note that this vector is only accessed from the UI thread.
-base::LazyInstance<std::vector<int /* process id */> > g_suspended_processes =
+base::LazyInstance<std::vector<int /* RenderProcessHost id */> >
+    g_suspended_processes = LAZY_INSTANCE_INITIALIZER;
+
+// Listens for RenderProcessHosts whose renderers have crashed. This is
+// necessary to ensure that we don't over-resume a RenderProcess as described
+// above.
+class SuspendedProcessWatcher : public content::RenderProcessHostObserver {
+  virtual void RenderProcessExited(content::RenderProcessHost* host,
+                                   base::ProcessHandle handle,
+                                   base::TerminationStatus status,
+                                   int exit_code) OVERRIDE {
+    std::vector<int>* suspended_processes = g_suspended_processes.Pointer();
+    std::vector<int>::iterator pos = std::find(suspended_processes->begin(),
+                                               suspended_processes->end(),
+                                               host->GetID());
+    if (pos != suspended_processes->end()) {
+      host->RemoveObserver(this);
+      suspended_processes->erase(pos);
+    }
+  }
+};
+
+base::LazyInstance<SuspendedProcessWatcher> g_suspended_processes_watcher =
     LAZY_INSTANCE_INITIALIZER;
 
 // Suspends timers in all current render processes.
 void SuspendWebKitSharedTimers(std::vector<int>* suspended_processes) {
   for (content::RenderProcessHost::iterator i(
           content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     content::RenderProcessHost* host = i.GetCurrentValue();
     suspended_processes->push_back(host->GetID());
     host->Send(new ViewMsg_SetWebKitSharedTimersSuspended(true));
+    host->AddObserver(g_suspended_processes_watcher.Pointer());

[klobag.chromium, 2014/02/25 22:19:27]

Hmm, are we calling this every time in suspend? Are we hitting the following
NOTREACHED() if you hit HOME/Chrome/HOME?

  // Add an observer to the list.  An observer should not be added to
  // the same list more than once.
  void AddObserver(ObserverType* obs) {
    if (std::find(observers_.begin(), observers_.end(), obs)
        != observers_.end()) {
      NOTREACHED() << "Observers can only be added once!";
      return;
    }
    observers_.push_back(obs);
  }

[Yaron, 2014/03/08 00:56:02]

Done.

   }
 }
 
 // Resumes timers in processes that were previously stopped.
 void ResumeWebkitSharedTimers(const std::vector<int>& suspended_processes) {
   for (std::vector<int>::const_iterator it = suspended_processes.begin();
        it != suspended_processes.end(); ++it) {
     content::RenderProcessHost* host = content::RenderProcessHost::FromID(*it);
     if (host)  // The process might have been killed since it was suspended.

[klobag.chromium, 2014/02/25 22:19:27]

Should we assert host not null here?

[Yaron, 2014/03/08 00:56:02]

Done.

       host->Send(new ViewMsg_SetWebKitSharedTimersSuspended(false));
   }
 }
 
 }  // namespace
 
 // Returns the first substring consisting of the address of a physical location.
 static jstring FindAddress(JNIEnv* env, jclass clazz, jstring addr) {
   base::string16 content_16 = ConvertJavaStringToUTF16(env, addr);
   base::string16 result_16;
@@ skipping 15 matching lines @@
   }
 }
 
 namespace content {
 
 bool RegisterWebViewStatics(JNIEnv* env) {
   return RegisterNativesImpl(env) >= 0;
 }
 
 }  // namespace content