Plugin Power Saver: Unthrottle dynamically sized plugins correctly.

components/plugins/renderer/loadable_plugin_placeholder.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 "components/plugins/renderer/loadable_plugin_placeholder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/json/string_escape.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/public/child/v8_value_converter.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "third_party/WebKit/public/web/WebDOMMessageEvent.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
@@ skipping 14 matching lines @@
 using blink::WebPlugin;
 using blink::WebPluginContainer;
 using blink::WebPluginParams;
 using blink::WebScriptSource;
 using blink::WebURLRequest;
 using content::PluginInstanceThrottler;
 using content::RenderThread;
 
 namespace plugins {
 
+namespace {

[Bernhard Bauer, 2015/06/10 11:13:24]

Nit: Anonymous namespace isn't necessary for constants, as they automatically
get internal linkage. If there is nothing else that warrants an anonymous
namespace, I would remove it.

[tommycli, 2015/06/10 18:55:52]

Done.

+
+#if defined(ENABLE_PLUGINS)
+// TODO(tommycli): After an unthrottling size update, re-check the size after
+// this delay, as Blink can report incorrect sizes to plugins while the
+// compositing state is dirty. Chosen because it seems to work.
+const int kSizeChangeRecheckDelayMilliseconds = 100;
+#endif
+
+}  // namespace
+
 #if defined(ENABLE_PLUGINS)
 void LoadablePluginPlaceholder::BlockForPowerSaverPoster() {
   DCHECK(!is_blocked_for_power_saver_poster_);
   is_blocked_for_power_saver_poster_ = true;
 
   render_frame()->RegisterPeripheralPlugin(
       GURL(GetPluginParams().url).GetOrigin(),
       base::Bind(&LoadablePluginPlaceholder::MarkPluginEssential,
                  weak_factory_.GetWeakPtr(),
                  PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_WHITELIST));
@@ skipping 19 matching lines @@
                         html_data,
                         placeholderDataUrl),
       is_blocked_for_background_tab_(false),
       is_blocked_for_prerendering_(false),
       is_blocked_for_power_saver_poster_(false),
       power_saver_enabled_(false),
       premade_throttler_(nullptr),
       allow_loading_(false),
       hidden_(false),
       finished_loading_(false),
+      in_size_recheck_(false),
+      size_update_weak_factory_(this),
       weak_factory_(this) {
 }
 
 LoadablePluginPlaceholder::~LoadablePluginPlaceholder() {
 }
 
 #if defined(ENABLE_PLUGINS)
 void LoadablePluginPlaceholder::MarkPluginEssential(
     PluginInstanceThrottler::PowerSaverUnthrottleMethod method) {
   if (!power_saver_enabled_)
@@ skipping 161 matching lines @@
     v8::Isolate* isolate) const {
 #if defined(ENABLE_PLUGINS)
   // Pass through JavaScript access to the underlying throttled plugin.
   if (premade_throttler_ && premade_throttler_->GetWebPlugin()) {
     return premade_throttler_->GetWebPlugin()->v8ScriptableObject(isolate);
   }
 #endif
   return v8::Local<v8::Object>();
 }
 
+#if defined(ENABLE_PLUGINS)
+void LoadablePluginPlaceholder::OnUnobscuredSizeUpdate(
+    const gfx::Size& unobscured_size) {
+  DCHECK(
+      content::RenderThread::Get()->GetTaskRunner()->BelongsToCurrentThread());
+  if (!power_saver_enabled_ || !premade_throttler_ || !finished_loading_)
+    return;
+
+  unobscured_size_ = unobscured_size;
+
+  // During a size recheck, we will get another notification into this method.
+  // Use this flag to early exit to prevent reentrancy issues.
+  if (in_size_recheck_)
+    return;
+
+  if (PluginInstanceThrottler::IsLargeContent(unobscured_size.width(),
+                                              unobscured_size.height())) {
+    if (!size_update_weak_factory_.HasWeakPtrs()) {

[Bernhard Bauer, 2015/06/10 11:13:24]

You could use a base::Timer for this instead of the second WeakPtrFactory.

[tommycli, 2015/06/10 18:55:52]

Done.

+      // TODO(tommycli): We have to post a delayed task to recheck the size, as
+      // Blink can report wrong sizes for partially obscured plugins while the
+      // compositing state is dirty. https://crbug.com/343769
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&LoadablePluginPlaceholder::RecheckSizeAndMaybeUnthrottle,
+                     size_update_weak_factory_.GetWeakPtr()),
+          base::TimeDelta::FromMilliseconds(
+              kSizeChangeRecheckDelayMilliseconds));
+    }
+  } else {
+    // Cancel any pending unthrottle due to resize calls.
+    size_update_weak_factory_.InvalidateWeakPtrs();
+  }
+}
+#endif  // defined(ENABLE_PLUGINS)
+
 void LoadablePluginPlaceholder::WasShown() {
   if (is_blocked_for_background_tab_) {
     is_blocked_for_background_tab_ = false;
     if (!LoadingBlocked())
       LoadPlugin();
   }
 }
 
 void LoadablePluginPlaceholder::OnLoadBlockedPlugins(
     const std::string& identifier) {
@@ skipping 104 matching lines @@
 const std::string& LoadablePluginPlaceholder::GetIdentifier() const {
   return identifier_;
 }
 
 bool LoadablePluginPlaceholder::LoadingBlocked() const {
   DCHECK(allow_loading_);
   return is_blocked_for_background_tab_ || is_blocked_for_power_saver_poster_ ||
          is_blocked_for_prerendering_;
 }
 
+#if defined(ENABLE_PLUGINS)
+void LoadablePluginPlaceholder::RecheckSizeAndMaybeUnthrottle() {
+  DCHECK(
+      content::RenderThread::Get()->GetTaskRunner()->BelongsToCurrentThread());
+  DCHECK(!in_size_recheck_);
+  in_size_recheck_ = true;
+
+  // Re-check the size in case the reported size was incorrect.
+  plugin()->container()->reportGeometry();
+
+  if (PluginInstanceThrottler::IsLargeContent(unobscured_size_.width(),
+                                              unobscured_size_.height())) {
+    MarkPluginEssential(
+        PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_SIZE_CHANGE);
+  }
+
+  in_size_recheck_ = false;
+}
+#endif  // defined(ENABLE_PLUGINS)
+
 }  // namespace plugins