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

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/json/string_escape.h"
 #include "base/strings/string_piece.h"
@@ skipping 32 matching lines @@
   is_blocked_for_power_saver_poster_ = true;
 
   render_frame()->RegisterPeripheralPlugin(
       GURL(GetPluginParams().url).GetOrigin(),
       base::Bind(&LoadablePluginPlaceholder::DisablePowerSaverForInstance,
                  weak_factory_.GetWeakPtr(),
                  PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_WHITELIST));
 }
 #endif
 
+void LoadablePluginPlaceholder::SetPremadePlugin(
+    blink::WebPlugin* plugin,
+    content::PluginInstanceThrottler* throttler) {
+  DCHECK(!premade_plugin_);
+  DCHECK(!premade_throttler_);
+  premade_plugin_ = plugin;
+  premade_throttler_ = throttler;
+
+  premade_throttler_->AddObserver(this);
+}
+
 LoadablePluginPlaceholder::LoadablePluginPlaceholder(
     content::RenderFrame* render_frame,
     WebLocalFrame* frame,
     const WebPluginParams& params,
     const std::string& html_data,
     GURL placeholderDataUrl)
     : PluginPlaceholder(render_frame,
                         frame,
                         params,
                         html_data,
                         placeholderDataUrl),
       is_blocked_for_background_tab_(false),
       is_blocked_for_prerendering_(false),
       is_blocked_for_power_saver_poster_(false),
       power_saver_mode_(PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL),
+      premade_plugin_(nullptr),
+      premade_throttler_(nullptr),
       allow_loading_(false),
       placeholder_was_replaced_(false),
       hidden_(false),
       finished_loading_(false),
       weak_factory_(this) {
 }
 
 LoadablePluginPlaceholder::~LoadablePluginPlaceholder() {
 #if defined(ENABLE_PLUGINS)
+  if (premade_throttler_)
+    premade_throttler_->RemoveObserver(this);
+
   if (!placeholder_was_replaced_ && !is_blocked_for_prerendering_ &&
       power_saver_mode_ != PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL) {
     PluginInstanceThrottler::RecordUnthrottleMethodMetric(
         PluginInstanceThrottler::UNTHROTTLE_METHOD_NEVER);
   }
 #endif
 }
 
 #if defined(ENABLE_PLUGINS)
 void LoadablePluginPlaceholder::DisablePowerSaverForInstance(
     PluginInstanceThrottler::PowerSaverUnthrottleMethod method) {
   if (power_saver_mode_ == PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL)
     return;
 
   power_saver_mode_ = PluginPowerSaverMode::POWER_SAVER_MODE_ESSENTIAL;
-  PluginInstanceThrottler::RecordUnthrottleMethodMetric(method);
+  if (premade_throttler_) {
+    premade_throttler_->MarkPluginEssential(method);
+  } else {
+    PluginInstanceThrottler::RecordUnthrottleMethodMetric(method);
+  }
+
   if (is_blocked_for_power_saver_poster_) {
     is_blocked_for_power_saver_poster_ = false;
     if (!LoadingBlocked())
       LoadPlugin();
   }
 }
 #endif
 
 gin::ObjectTemplateBuilder LoadablePluginPlaceholder::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return gin::Wrappable<PluginPlaceholder>::GetObjectTemplateBuilder(isolate)
       .SetMethod("load", &LoadablePluginPlaceholder::LoadCallback)
       .SetMethod("hide", &LoadablePluginPlaceholder::HideCallback)
       .SetMethod("didFinishLoading",
                  &LoadablePluginPlaceholder::DidFinishLoadingCallback);
 }
 
 void LoadablePluginPlaceholder::ReplacePlugin(WebPlugin* new_plugin) {
   CHECK(plugin());
   if (!new_plugin)
     return;
   WebPluginContainer* container = plugin()->container();
   // Set the new plug-in on the container before initializing it.
   container->setPlugin(new_plugin);
   // Save the element in case the plug-in is removed from the page during
   // initialization.
   WebElement element = container->element();
-  if (!new_plugin->initialize(container)) {
+  if (new_plugin != premade_plugin_ && !new_plugin->initialize(container)) {
     // We couldn't initialize the new plug-in. Restore the old one and abort.
     container->setPlugin(plugin());
     return;
   }
 
   // The plug-in has been removed from the page. Destroy the old plug-in. We
   // will be destroyed as soon as V8 garbage collects us.
   if (!element.pluginContainer()) {
     plugin()->destroy();
     return;
   }
 
+  placeholder_was_replaced_ = true;
+
   // During initialization, the new plug-in might have replaced itself in turn
   // with another plug-in. Make sure not to use the passed in |new_plugin| after
   // this point.
   new_plugin = container->plugin();
 
   plugin()->RestoreTitleText();
   container->invalidate();
   container->reportGeometry();
   plugin()->ReplayReceivedData(new_plugin);
   plugin()->destroy();
-
-  placeholder_was_replaced_ = true;
 }
 
 void LoadablePluginPlaceholder::HidePlugin() {
   hidden_ = true;
   if (!plugin())
     return;
   WebPluginContainer* container = plugin()->container();
   WebElement element = container->element();
   element.setAttribute("style", "display: none;");
   // If we have a width and height, search for a parent (often <div>) with the
@@ skipping 45 matching lines @@
 
 void LoadablePluginPlaceholder::UpdateMessage() {
   if (!plugin())
     return;
   std::string script =
       "window.setMessage(" + base::GetQuotedJSONString(message_) + ")";
   plugin()->web_view()->mainFrame()->executeScript(
       WebScriptSource(base::UTF8ToUTF16(script)));
 }
 
-void LoadablePluginPlaceholder::ShowContextMenu(const WebMouseEvent& event) {
-  // Does nothing by default. Will be overridden if a specific browser wants
-  // a context menu.
-  return;
+void LoadablePluginPlaceholder::PluginDestroyed() {
+  // Since the premade plugin has been detached from the container, it will not
+  // be automatically destroyed along with the page.
+  if (!placeholder_was_replaced_ && premade_plugin_) {
+    premade_plugin_->destroy();
+    premade_plugin_ = nullptr;
+    premade_throttler_ = nullptr;
+  }
+
+  PluginPlaceholder::PluginDestroyed();
 }
 
 void LoadablePluginPlaceholder::WasShown() {
   if (is_blocked_for_background_tab_) {
     is_blocked_for_background_tab_ = false;
     if (!LoadingBlocked())
       LoadPlugin();
   }
 }
 
+void LoadablePluginPlaceholder::OnThrottleStateChange() {
+  DCHECK(premade_plugin_);
+  DCHECK(premade_throttler_);
+  if (!premade_throttler_->IsThrottled()) {
+    // Premade plugin has been unthrottled externally (by audio playback, etc.).
+    LoadPlugin();
+  }
+}
+
 void LoadablePluginPlaceholder::OnLoadBlockedPlugins(
     const std::string& identifier) {
   if (!identifier.empty() && identifier != identifier_)
     return;
 
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Load_UI"));
   LoadPlugin();
 }
 
 void LoadablePluginPlaceholder::OnSetIsPrerendering(bool is_prerendering) {
@@ skipping 12 matching lines @@
   // event propagation changes between "close" vs. "click-to-play".
   if (hidden_)
     return;
   if (!plugin())
     return;
   if (!allow_loading_) {
     NOTREACHED();
     return;
   }
 
-  // TODO(mmenke):  In the case of prerendering, feed into
-  //                ChromeContentRendererClient::CreatePlugin instead, to
-  //                reduce the chance of future regressions.
-  scoped_ptr<PluginInstanceThrottler> throttler;
+  if (premade_plugin_) {
+    // Show the (presumably hidden) premade plugin again.
+    premade_plugin_->updateVisibility(true);
+
+    ReplacePlugin(premade_plugin_);
+
+    premade_throttler_->RemoveObserver(this);
+    premade_plugin_ = nullptr;
+    premade_throttler_ = nullptr;
+  } else {
+    // TODO(mmenke):  In the case of prerendering, feed into
+    //                ChromeContentRendererClient::CreatePlugin instead, to
+    //                reduce the chance of future regressions.
+    scoped_ptr<PluginInstanceThrottler> throttler;
 #if defined(ENABLE_PLUGINS)
-  throttler = PluginInstanceThrottler::Get(
-      render_frame(), GetPluginParams().url, power_saver_mode_);
+    throttler = PluginInstanceThrottler::Get(
+        render_frame(), GetPluginParams().url, power_saver_mode_);
 #endif
-  WebPlugin* plugin = render_frame()->CreatePlugin(
-      GetFrame(), plugin_info_, GetPluginParams(), throttler.Pass());
-  ReplacePlugin(plugin);
+    WebPlugin* plugin = render_frame()->CreatePlugin(
+        GetFrame(), plugin_info_, GetPluginParams(), throttler.Pass());
+
+    ReplacePlugin(plugin);
+  }
 }
 
 void LoadablePluginPlaceholder::LoadCallback() {
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Load_Click"));
 #if defined(ENABLE_PLUGINS)
   // If the user specifically clicks on the plug-in content's placeholder,
   // disable power saver throttling for this instance.
   DisablePowerSaverForInstance(
       PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_CLICK);
 #endif
   LoadPlugin();
 }
 
 void LoadablePluginPlaceholder::HideCallback() {
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Hide_Click"));
   HidePlugin();
 }
 
 void LoadablePluginPlaceholder::DidFinishLoadingCallback() {
   finished_loading_ = true;
   if (message_.length() > 0)
     UpdateMessage();
+
+  // Wait for the placeholder to finish loading to hide the premade plugin.
+  // This is necessary to prevent a flicker.
+  if (premade_plugin_ && !placeholder_was_replaced_) {
+    premade_plugin_->updateVisibility(false);
+  }
 }
 
 void LoadablePluginPlaceholder::SetPluginInfo(
     const content::WebPluginInfo& plugin_info) {
   plugin_info_ = plugin_info;
 }
 
 const content::WebPluginInfo& LoadablePluginPlaceholder::GetPluginInfo() const {
   return plugin_info_;
 }
 
 void LoadablePluginPlaceholder::SetIdentifier(const std::string& identifier) {
   identifier_ = identifier;
 }
 
 bool LoadablePluginPlaceholder::LoadingBlocked() const {
   DCHECK(allow_loading_);
   return is_blocked_for_background_tab_ || is_blocked_for_power_saver_poster_ ||
          is_blocked_for_prerendering_;
 }
 
 }  // namespace plugins