Implement Just-In-Time Flash updates.

chrome/browser/plugins/plugin_observer.cc

 // Copyright (c) 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 "chrome/browser/plugins/plugin_observer.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/crash_logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/plugins/plugin_finder.h"
 #include "chrome/browser/plugins/plugin_infobar_delegates.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_modal_confirm_dialog.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/component_updater/component_updater_service.h"
 #include "components/content_settings/content/common/content_settings_messages.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "components/infobars/core/infobar_delegate.h"
 #include "components/infobars/core/simple_alert_infobar_delegate.h"
 #include "components/metrics_services_manager/metrics_services_manager.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 121 matching lines @@
       std::unique_ptr<ConfirmInfoBarDelegate>(
           new ReloadPluginInfoBarDelegate(controller, message))));
 }
 
 ReloadPluginInfoBarDelegate::ReloadPluginInfoBarDelegate(
     content::NavigationController* controller,
     const base::string16& message)
     : controller_(controller),
       message_(message) {}
 
-ReloadPluginInfoBarDelegate::~ReloadPluginInfoBarDelegate(){ }
+ReloadPluginInfoBarDelegate::~ReloadPluginInfoBarDelegate() { }
 
 infobars::InfoBarDelegate::InfoBarIdentifier
 ReloadPluginInfoBarDelegate::GetIdentifier() const {
   return RELOAD_PLUGIN_INFOBAR_DELEGATE;
 }
 
 int ReloadPluginInfoBarDelegate::GetIconId() const {
   return IDR_INFOBAR_PLUGIN_CRASHED;
 }
 
@@ skipping 70 matching lines @@
   }
 
  private:
   // Weak pointer; owns us.
   PluginObserver* observer_;
 
   int routing_id_;
 };
 #endif  // defined(ENABLE_PLUGIN_INSTALLATION)
 
+PluginObserver::ComponentObserver::ComponentObserver(
+    PluginObserver* observer,
+    int routing_id,
+    const std::string& component_id)
+    : observer_(observer),
+      routing_id_(routing_id),
+      component_id_(component_id) {}
+
+void PluginObserver::ComponentObserver::OnEvent(Events event,
+                                                const std::string& id) {
+  if (id != component_id_)
+    return;
+  switch (event) {
+    case Events::COMPONENT_UPDATED:
+      observer_->Send(
+          new ChromeViewMsg_PluginComponentUpdateSuccess(routing_id_));
+      observer_->RemoveComponentObserver(routing_id_);
+      break;
+    case Events::COMPONENT_UPDATE_FOUND:
+      observer_->Send(
+          new ChromeViewMsg_PluginComponentUpdateDownloading(routing_id_));
+      break;
+    case Events::COMPONENT_NOT_UPDATED:
+      observer_->Send(
+          new ChromeViewMsg_PluginComponentUpdateFailure(routing_id_));
+      observer_->RemoveComponentObserver(routing_id_);
+      break;
+    default:
+      // No message to send.
+      break;
+  }
+}
+
 PluginObserver::PluginObserver(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       weak_ptr_factory_(this) {
 }
 
 PluginObserver::~PluginObserver() {
 #if defined(ENABLE_PLUGIN_INSTALLATION)
   STLDeleteValues(&plugin_placeholders_);
 #endif
+  auto cus = g_browser_process->component_updater();
+  for (const auto& observer : component_observers_) {
+    cus->RemoveObserver(observer.second.get());
+  }
 }
 
 void PluginObserver::PluginCrashed(const base::FilePath& plugin_path,
                                    base::ProcessId plugin_pid) {
   DCHECK(!plugin_path.value().empty());
 
   base::string16 plugin_name =
       PluginService::GetInstance()->GetPluginDisplayNameByPath(plugin_path);
   base::string16 infobar_text;
 #if defined(OS_WIN)
@@ skipping 37 matching lines @@
       &web_contents()->GetController(),
       infobar_text);
 }
 
 bool PluginObserver::OnMessageReceived(
       const IPC::Message& message,
       content::RenderFrameHost* render_frame_host) {
   IPC_BEGIN_MESSAGE_MAP(PluginObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_BlockedOutdatedPlugin,
                         OnBlockedOutdatedPlugin)
+    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_BlockedComponentUpdatedPlugin,
+                        OnBlockedComponentUpdatedPlugin)
 #if defined(ENABLE_PLUGIN_INSTALLATION)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RemovePluginPlaceholderHost,
                         OnRemovePluginPlaceholderHost)
 #endif
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_OpenAboutPlugins,
                         OnOpenAboutPlugins)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CouldNotLoadPlugin,
                         OnCouldNotLoadPlugin)
 
     IPC_MESSAGE_UNHANDLED(return false)
@@ skipping 18 matching lines @@
   } else {
     NOTREACHED();
   }
 #else
   // If we don't support third-party plugin installation, we shouldn't have
   // outdated plugins.
   NOTREACHED();
 #endif  // defined(ENABLE_PLUGIN_INSTALLATION)
 }
 
+void PluginObserver::OnBlockedComponentUpdatedPlugin(
+    int placeholder_id,
+    const std::string& identifier) {
+  auto observer = new ComponentObserver(this, placeholder_id, identifier);

[Sorin Jianu, 2016/07/28 21:04:05]

Clarify the ownership of the ComponentObserver by using a unique_ptr and
transfer it over to the map before exiting the function.

[waffles, 2016/07/28 23:05:52]

Done.

+  component_observers_[placeholder_id] =
+      base::WrapUnique<ComponentObserver>(observer);
+  component_updater::ComponentUpdateService* cus =
+      g_browser_process->component_updater();
+  cus->AddObserver(observer);
+  cus->GetOnDemandUpdater().OnDemandUpdate(identifier);
+}
+
+void PluginObserver::RemoveComponentObserver(int placeholder_id) {
+  auto it = component_observers_.find(placeholder_id);
+  if (it == component_observers_.end()) {
+    NOTREACHED();

[Sorin Jianu, 2016/07/28 21:04:05]

https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md

"not handle DCHECK() failures"

[waffles, 2016/07/28 23:05:52]

Done.

[Bernhard Bauer, 2016/07/29 09:14:24]

I would be careful there -- this is handling an IPC message from an untrusted
process, which could send us anything. I think most STL map implementations
won't do something too bad when dereferencing their end() iterator, but it still
seems somewhat dangerous. So, technically we should probably handle this error
and call bad_message::ReceivedBadMessage() to kill the renderer process.
(Although as you can see in chrome/browser/bad_message.h, we are not very good
at actually following through on this.)

[waffles, 2016/07/29 21:07:25]

In this case, RemoveComponentObserver is only triggered by
PluginObserver::ComponentObserver::OnEvent, and routing_id comes from that
class's member (not the event). Originally this ID is from the renderer, but
it's an invariant that the ID should exist in component_observers_ if we created
a ComponentObserver with that ID; so I think the DCHECK is safe here.

(Note that this is asymmetrical with OnRemovePluginPlaceholderHost, below - I've
reverted the behavior there to the original.)

[Bernhard Bauer, 2016/08/01 09:30:39]

Oh, right. Cool!

+    return;
+  }
+  g_browser_process->component_updater()->RemoveObserver(it->second.get());
+  component_observers_.erase(it);
+}
+
 #if defined(ENABLE_PLUGIN_INSTALLATION)
 void PluginObserver::OnRemovePluginPlaceholderHost(int placeholder_id) {
   std::map<int, PluginPlaceholderHost*>::iterator it =
       plugin_placeholders_.find(placeholder_id);
   if (it == plugin_placeholders_.end()) {
     NOTREACHED();
     return;
   }
   delete it->second;
   plugin_placeholders_.erase(it);
@@ skipping 21 matching lines @@
       IDR_INFOBAR_PLUGIN_CRASHED,
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
       gfx::VectorIconId::EXTENSION_CRASHED,
 #else
       gfx::VectorIconId::VECTOR_ICON_NONE,
 #endif
       l10n_util::GetStringFUTF16(IDS_PLUGIN_INITIALIZATION_ERROR_PROMPT,
                                  plugin_name),
       true);
 }