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 {
+
+// TODO(tommycli): After an unthrottling size update, re-check the size after

[groby-ooo-7-16, 2015/06/05 23:03:45]

#if defined(ENABLE_PLUGINS)

[tommycli, 2015/06/06 01:23:22]

Done.

+// this delay, as Blink can report incorrect sizes to plugins while the
+// compositing state is dirty. Chosen because it seems to work.

[groby-ooo-7-16, 2015/06/05 23:03:45]

Please add a bug to undo this. I don't trust TODO's :)

[tommycli, 2015/06/06 01:23:22]

Done.

+const int kSizeChangeRecheckDelayMilliseconds = 100;
+
+}  // 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) {
+  if (!power_saver_enabled_ || !premade_throttler_ || !finished_loading_)
+    return;
+
+  unobscured_size_ = unobscured_size;
+
+  if (in_size_recheck_)

[groby-ooo-7-16, 2015/06/05 23:03:45]

Why do we have this test?

[tommycli, 2015/06/06 01:23:21]

Done. Added comment above.

+    return;
+
+  if (PluginInstanceThrottler::IsLargeContent(unobscured_size.width(),
+                                              unobscured_size.height())) {
+    if (!size_update_weak_factory_.HasWeakPtrs()) {
+      // 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

[groby-ooo-7-16, 2015/06/05 23:03:45]

Once that bug is gone, does this whole machinery vanish?

[tommycli, 2015/06/06 01:23:22]

Yes, if there was no bug, and the reported plugin size was always accurate,
there would be no reason to do a delayed size recheck. We would just
MarkPluginEssential directly here.

+      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(!in_size_recheck_);

[groby-ooo-7-16, 2015/06/05 23:03:45]

Do we need to protect against reentrancy?

[tommycli, 2015/06/06 01:23:21]

Uh.... well I hope this never happens. If re-entrancy does happen, I'm not sure
what the behavior is.

+  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