Plugin Power Saver: Add UI Overlay to throttled plugin using placeholder.

chrome/renderer/plugins/plugin_preroller.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 "chrome/renderer/plugins/plugin_preroller.h"
+
+#include "base/base64.h"
+#include "chrome/grit/renderer_resources.h"
+#include "chrome/renderer/plugins/chrome_plugin_placeholder.h"
+#include "third_party/WebKit/public/platform/WebRect.h"
+#include "third_party/WebKit/public/web/WebElement.h"
+#include "third_party/WebKit/public/web/WebPlugin.h"
+#include "third_party/WebKit/public/web/WebPluginContainer.h"
+#include "ui/gfx/codec/png_codec.h"
+
+PluginPreroller::PluginPreroller(content::RenderFrame* render_frame,
+                                 blink::WebLocalFrame* frame,
+                                 const blink::WebPluginParams& params,
+                                 const content::WebPluginInfo& info,
+                                 const std::string& identifier,
+                                 const base::string16& name,
+                                 const base::string16& message,
+                                 blink::WebPlugin* plugin,
+                                 content::PluginInstanceThrottler* throttler)
+    : render_frame_(render_frame),
+      frame_(frame),
+      params_(params),
+      info_(info),
+      identifier_(identifier),
+      name_(name),
+      message_(message),
+      plugin_(plugin),
+      throttler_(throttler) {
+  DCHECK(plugin);
+  DCHECK(throttler);
+  throttler_->AddObserver(this);
+}
+
+PluginPreroller::~PluginPreroller() {
+  if (throttler_)
+    throttler_->RemoveObserver(this);
+}
+
+void PluginPreroller::OnKeyframeExtracted(const SkBitmap* bitmap) {
+  std::vector<unsigned char> png_data;
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(*bitmap, false, &png_data)) {
+    DLOG(ERROR) << "Provided keyframe could not be encoded as PNG.";
+  }
+
+  std::string png_as_string(reinterpret_cast<char*>(&png_data[0]),
+                            png_data.size());
+
+  std::string data_url_header = "data:image/png;base64,";
+  std::string data_url_body;
+  base::Base64Encode(png_as_string, &data_url_body);
+  keyframe_data_url_ = data_url_header + data_url_body;
+}
+
+void PluginPreroller::OnThrottleStateChange() {

[tommycli, 2015/01/29 20:02:43]

bauerb: Extra scrutiny here. I based this code on
LoadablePluginPlaceholder::ReplacePlugin. I think this method can be simpler
because we're replacing it with LoadablePluginPlaceholder->plugin() which is
more predictable, but i'm not sure.

[Bernhard Bauer, 2015/01/30 14:12:56]

Yeah... I'll add some comments below.

+  if (throttler_->IsThrottled()) {
+    ChromePluginPlaceholder* placeholder =
+        ChromePluginPlaceholder::CreateBlockedPlugin(
+            render_frame_, frame_, params_, info_, identifier_, name_,
+            IDR_PLUGIN_POSTER_HTML, message_, GURL(keyframe_data_url_), plugin_,
+            throttler_);
+    placeholder->set_power_saver_mode(
+        content::PluginPowerSaverMode::POWER_SAVER_MODE_PERIPHERAL_THROTTLED);
+    placeholder->set_allow_loading(true);
+
+    // Set the new plug-in on the container before initializing it.
+    blink::WebPluginContainer* container = plugin_->container();
+    container->setPlugin(placeholder->plugin());
+
+    if (!placeholder->plugin()->initialize(container)) {
+      // We couldn't initialize the new plug-in. Restore the old one and abort.
+      container->setPlugin(plugin_);
+      placeholder->plugin()->destroy();
+      delete this;
+      return;
+    }
+
+    placeholder->plugin()->RestoreTitleText();
+    container->invalidate();
+    container->reportGeometry();
+
+    delete this;
+  }
+}
+
+void PluginPreroller::OnThrottlerDestroyed() {

[tommycli, 2015/01/29 20:02:43]

Relying on the fact that when the plugin gets destroyed, so does the throttler.

Not sure if more is needed to prevent leaks, or you can recommend a better
lifetime management strategy.

[groby-ooo-7-16, 2015/01/30 02:22:44]

If the throttler's lifetime controls the prerollers lifetime, why not have one
own the other? (And if we _have_ to do this, don't bother zeroing out throttler_
- the object is *dead* after delete this, and zeroing out members will at best
mask use-after-free errors)

[Bernhard Bauer, 2015/01/30 14:12:56]

The Preroller is just an observer of the throttler, and the throttler doesn't
own its observers. It also can't know directly about the Preroller, because the
latter lives in chrome/ and the former in content/ :)
There is a check in the destructor to only remove ourselves as an observer if
the throttler is still alive; that might be the reason for zeroing it out here.

[groby-ooo-7-16, 2015/01/30 15:16:37]

Indeed it is. I missed the call to "delete this" in OnThrottleStateChange :(

+  throttler_ = nullptr;
+  delete this;
+}