Implement renderer importance API for WebView

android_webview/native/aw_contents.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 "android_webview/native/aw_contents.h"
 
 #include <limits>
 #include <utility>
 
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_browser_main_parts.h"
 #include "android_webview/browser/aw_resource_context.h"
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/net_disk_cache_remover.h"
 #include "android_webview/browser/render_thread_manager.h"
 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/common/aw_hit_test_data.h"
 #include "android_webview/common/aw_switches.h"
 #include "android_webview/common/devtools_instrumentation.h"
 #include "android_webview/native/aw_autofill_client.h"
 #include "android_webview/native/aw_contents_client_bridge.h"
 #include "android_webview/native/aw_contents_io_thread_client_impl.h"
 #include "android_webview/native/aw_contents_lifecycle_notifier.h"
 #include "android_webview/native/aw_gl_functor.h"
 #include "android_webview/native/aw_pdf_exporter.h"
 #include "android_webview/native/aw_picture.h"
+#include "android_webview/native/aw_renderer_priority_manager.h"
 #include "android_webview/native/aw_web_contents_delegate.h"
 #include "android_webview/native/java_browser_view_renderer_helper.h"
 #include "android_webview/native/permission/aw_permission_request.h"
 #include "android_webview/native/permission/permission_request_handler.h"
 #include "android_webview/native/permission/simple_permission_request.h"
 #include "android_webview/native/state_serializer.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
@@ skipping 20 matching lines @@
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/message_port_provider.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/ssl_status.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/mhtml_generation_params.h"
 #include "content/public/common/renderer_preferences.h"
 #include "jni/AwContents_jni.h"
 #include "net/base/auth.h"
 #include "net/cert/x509_certificate.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
-
 struct AwDrawSWFunctionTable;
 
 using autofill::ContentAutofillDriverFactory;
 using autofill::AutofillManager;
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaParamRef;
@@ skipping 12 matching lines @@
 
 bool g_should_download_favicons = false;
 
 bool g_force_auxiliary_bitmap_rendering = false;
 
 std::string g_locale;
 
 std::string g_locale_list;
 
 const void* kAwContentsUserDataKey = &kAwContentsUserDataKey;
+const void* kComputedRendererPriorityUserDataKey =
+    &kComputedRendererPriorityUserDataKey;
 
 class AwContentsUserData : public base::SupportsUserData::Data {
  public:
   explicit AwContentsUserData(AwContents* ptr) : contents_(ptr) {}
 
   static AwContents* GetContents(WebContents* web_contents) {
     if (!web_contents)
       return NULL;
     AwContentsUserData* data = static_cast<AwContentsUserData*>(
         web_contents->GetUserData(kAwContentsUserDataKey));
@@ skipping 67 matching lines @@
   return AwContents::FromWebContents(web_contents);
 }
 
 AwContents::AwContents(std::unique_ptr<WebContents> web_contents)
     : content::WebContentsObserver(web_contents.get()),
       functor_(nullptr),
       browser_view_renderer_(
           this,
           BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)),
       web_contents_(std::move(web_contents)),
-      renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
+      renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()),
+      renderer_requested_priority_(
+          AwRendererPriorityManager::RENDERER_PRIORITY_HIGH),
+      renderer_priority_waived_when_not_visible_(false) {
   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
   icon_helper_.reset(new IconHelper(web_contents_.get()));
   icon_helper_->SetListener(this);
   web_contents_->SetUserData(android_webview::kAwContentsUserDataKey,
                              new AwContentsUserData(this));
   browser_view_renderer_.RegisterWithWebContents(web_contents_.get());
 
   CompositorID compositor_id;
   if (web_contents_->GetRenderProcessHost() &&
       web_contents_->GetRenderViewHost()) {
     compositor_id.process_id = web_contents_->GetRenderProcessHost()->GetID();
     compositor_id.routing_id =
         web_contents_->GetRenderViewHost()->GetRoutingID();
   }
 
   browser_view_renderer_.SetActiveCompositorID(compositor_id);
   render_view_host_ext_.reset(
       new AwRenderViewHostExt(this, web_contents_.get()));
 
   permission_request_handler_.reset(
       new PermissionRequestHandler(this, web_contents_.get()));
 
   AwAutofillClient* autofill_manager_delegate =
       AwAutofillClient::FromWebContents(web_contents_.get());
   if (autofill_manager_delegate)
     InitAutofillIfNecessary(autofill_manager_delegate->GetSaveFormData());
   content::SynchronousCompositor::SetClientForWebContents(
       web_contents_.get(), &browser_view_renderer_);
+  UpdateRendererPriority();
+  web_contents_->GetRenderProcessHost()->AddObserver(this);
   AwContentsLifecycleNotifier::OnWebViewCreated();
 }
 
 void AwContents::SetJavaPeers(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& aw_contents,
     const JavaParamRef<jobject>& web_contents_delegate,
     const JavaParamRef<jobject>& contents_client_bridge,
     const JavaParamRef<jobject>& io_thread_client,
@@ skipping 59 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
   Java_AwContents_setAwAutofillClient(env, obj, client);
 }
 
 AwContents::~AwContents() {
   DCHECK_EQ(this, AwContents::FromWebContents(web_contents_.get()));
+  web_contents_->GetRenderProcessHost()->RemoveObserver(this);
+  UpdateRendererPriority(AwRendererPriorityManager::RENDERER_PRIORITY_WAIVED);
   web_contents_->RemoveUserData(kAwContentsUserDataKey);
   if (find_helper_.get())
     find_helper_->SetListener(NULL);
   if (icon_helper_.get())
     icon_helper_->SetListener(NULL);
   base::subtle::Atomic32 instance_count =
       base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, -1);
   // When the last WebView is destroyed free all discardable memory allocated by
   // Chromium, because the app process may continue to run for a long time
   // without ever using another WebView.
@@ skipping 532 matching lines @@
                                int oh) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnSizeChanged(w, h);
 }
 
 void AwContents::SetViewVisibility(JNIEnv* env,
                                    const JavaParamRef<jobject>& obj,
                                    bool visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetViewVisibility(visible);
+  UpdateRendererPriority();
 }
 
 void AwContents::SetWindowVisibility(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj,
                                      bool visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetWindowVisibility(visible);
+  UpdateRendererPriority();
 }
 
 void AwContents::SetIsPaused(JNIEnv* env,
                              const JavaParamRef<jobject>& obj,
                              bool paused) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetIsPaused(paused);
+  UpdateRendererPriority();
 }
 
 void AwContents::OnAttachedToWindow(JNIEnv* env,
                                     const JavaParamRef<jobject>& obj,
                                     int w,
                                     int h) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnAttachedToWindow(w, h);
+  UpdateRendererPriority();
 }
 
 void AwContents::OnDetachedFromWindow(JNIEnv* env,
                                       const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.OnDetachedFromWindow();
+  UpdateRendererPriority();
 }
 
 bool AwContents::IsVisible(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   return browser_view_renderer_.IsClientVisible();
 }
 
 base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetOpaqueState(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 266 matching lines @@
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     jlong request_id,
     const JavaParamRef<jobject>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   web_contents_->GetMainFrame()->InsertVisualStateCallback(
       base::Bind(&InvokeVisualStateCallback, java_ref_, request_id,
                  ScopedJavaGlobalRef<jobject>(env, callback)));
 }
 
+void AwContents::UpdateRendererPriority(
+    AwRendererPriorityManager::RendererPriority base_priority) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  content::RenderProcessHost* rph = web_contents_->GetRenderProcessHost();
+  AwRendererPriorityManager::RendererPriority computed_priority = base_priority;
+
+  std::unique_ptr<content::RenderWidgetHostIterator> widgets(
+      content::RenderWidgetHost::GetRenderWidgetHosts());
+  content::RenderWidgetHost* widget;
+  while ((widget = widgets->GetNextHost()) != nullptr &&
+         computed_priority <
+             AwRendererPriorityManager::RENDERER_PRIORITY_HIGH) {
+    content::RenderViewHost* view = content::RenderViewHost::From(widget);
+    if (view && rph == view->GetProcess()) {
+      content::WebContents* wc = content::WebContents::FromRenderViewHost(view);
+      if (wc && wc != web_contents_.get()) {
+        computed_priority =
+            std::max(FromWebContents(wc)->GetComputedRendererPriority(),
+                     computed_priority);
+      }
+    }
+  }
+  GetAwRendererPriorityManager()->SetRendererPriority(computed_priority);
+}
+
+AwRendererPriorityManager::RendererPriority
+AwContents::GetComputedRendererPriority() {
+  if (renderer_priority_waived_when_not_visible_ &&
+      !browser_view_renderer_.IsClientVisible()) {
+    return AwRendererPriorityManager::RENDERER_PRIORITY_WAIVED;
+  }
+  return renderer_requested_priority_;
+}
+
+void AwContents::UpdateRendererPriority() {
+  UpdateRendererPriority(GetComputedRendererPriority());
+}
+
+AwRendererPriorityManager* AwContents::GetAwRendererPriorityManager() {
+  content::RenderProcessHost* rph = web_contents_->GetRenderProcessHost();
+  AwRendererPriorityManager* manager = static_cast<AwRendererPriorityManager*>(
+      rph->GetUserData(kComputedRendererPriorityUserDataKey));
+  if (manager == nullptr) {
+    rph->SetUserData(kComputedRendererPriorityUserDataKey,
+                     manager = new AwRendererPriorityManager(rph));
+  }
+  return manager;
+}
+
+AwRendererPriorityManager::RendererPriority
+AwContents::GetCurrentRendererPriority() {
+  return GetAwRendererPriorityManager()->GetRendererPriority();
+}
+
+jint AwContents::GetRendererCurrentPriority(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj) {
+  return GetCurrentRendererPriority();
+}
+
+jint AwContents::GetRendererRequestedPriority(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj) {
+  return renderer_requested_priority_;
+}
+
+jboolean AwContents::GetRendererPriorityWaivedWhenNotVisible(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj) {
+  return renderer_priority_waived_when_not_visible_;
+}
+
+void AwContents::SetRendererPriorityPolicy(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    jint renderer_requested_priority,
+    jboolean renderer_priority_waived_when_not_visible) {
+  renderer_requested_priority_ =
+      static_cast<AwRendererPriorityManager::RendererPriority>(
+          renderer_requested_priority);
+  renderer_priority_waived_when_not_visible_ =
+      renderer_priority_waived_when_not_visible;
+  UpdateRendererPriority(renderer_requested_priority_);
+}
+
 void AwContents::ClearView(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.ClearView();
 }
 
 void AwContents::SetExtraHeadersForUrl(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jstring>& url,
     const JavaParamRef<jstring>& jextra_headers) {
@@ skipping 150 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
 
   return Java_AwContents_onRenderProcessGoneDetail(env, obj,
       child_process_id, crashed);
 }
 
+void AwContents::RenderProcessReady(content::RenderProcessHost* host) {
+  UpdateRendererPriority();
+}
+
 }  // namespace android_webview