[HBD] Remove PluginCache and reload plugin list when origin changes

content/browser/frame_host/render_frame_message_filter.cc

 // Copyright 2013 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 "content/browser/frame_host/render_frame_message_filter.h"
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
@@ skipping 448 matching lines @@
           render_process_id_, render_frame_id, options)) {
     net::URLRequestContext* context = GetRequestContextForURL(url);
     // Pass a null callback since we don't care about when the 'set' completes.
     context->cookie_store()->SetCookieWithOptionsAsync(
         url, cookie, options, net::CookieStore::SetCookiesCallback());
   }
 }
 
 #if defined(ENABLE_PLUGINS)
 
-void RenderFrameMessageFilter::OnGetPlugins(
-    bool refresh,
-    IPC::Message* reply_msg) {
+void RenderFrameMessageFilter::OnGetPlugins(bool refresh,
+                                            url::Origin main_frame_origin,
+                                            IPC::Message* reply_msg) {
   // Don't refresh if the specified threshold has not been passed.  Note that
   // this check is performed before off-loading to the file thread.  The reason
   // we do this is that some pages tend to request that the list of plugins be
   // refreshed at an excessive rate.  This instigates disk scanning, as the list
   // is accumulated by doing multiple reads from disk.  This effect is
   // multiplied when we have several pages requesting this operation.
   if (refresh) {
     const base::TimeDelta threshold = base::TimeDelta::FromSeconds(
         kPluginsRefreshThresholdInSeconds);
     const base::TimeTicks now = base::TimeTicks::Now();
     if (now - last_plugin_refresh_time_ >= threshold) {
       // Only refresh if the threshold hasn't been exceeded yet.
       PluginServiceImpl::GetInstance()->RefreshPlugins();
       last_plugin_refresh_time_ = now;
     }
   }
 
-  PluginServiceImpl::GetInstance()->GetPlugins(base::Bind(
-      &RenderFrameMessageFilter::GetPluginsCallback, this, reply_msg));
+  PluginServiceImpl::GetInstance()->GetPlugins(
+      base::Bind(&RenderFrameMessageFilter::GetPluginsCallback, this, reply_msg,
+                 main_frame_origin));
 }
 
 void RenderFrameMessageFilter::GetPluginsCallback(
     IPC::Message* reply_msg,
+    url::Origin main_frame_origin,
     const std::vector<WebPluginInfo>& all_plugins) {
   // Filter the plugin list.
   PluginServiceFilter* filter = PluginServiceImpl::GetInstance()->GetFilter();
   std::vector<WebPluginInfo> plugins;
 
   int child_process_id = -1;
   int routing_id = MSG_ROUTING_NONE;
   // In this loop, copy the WebPluginInfo (and do not use a reference) because
   // the filter might mutate it.
   for (WebPluginInfo plugin : all_plugins) {
-    if (!filter || filter->IsPluginAvailable(child_process_id,
-                                             routing_id,
-                                             resource_context_,
-                                             GURL(),
-                                             GURL(),
-                                             &plugin)) {
+    if (!filter ||
+        filter->IsPluginAvailable(

[alexmos, 2016/08/02 22:06:27]

Looking at IsPluginAvailable implementations, they don't use the policy_url
param that's populated here atm - is that going to come in another CL?

[trizzofo, 2016/08/03 00:08:37]

Yes, we are working on it:
https://crrev.com/2208463002

+            child_process_id, routing_id, resource_context_, GURL(),
+            GURL(main_frame_origin.Serialize()), &plugin)) {

[alexmos, 2016/08/02 22:06:27]

Is there a way to just use url::Origins in IsPluginAvailable as well?  It'd be
nice to minimize these kinds of origin conversions when possible, as they might
lose information.  In particular, a GURL doesn't track uniqueness: a unique
origin can't access another unique origin, but a GURL created from one unique
origin (serialized as "null") would be invalid and would be considered equal to
a GURL created from another unique origin.  So you'd need to be very careful in
comparing them.

[trizzofo, 2016/08/03 00:08:37]

The only reason why we're using unique origins is because it's empty, so, when
it reaches isPluginAvailable(), the default content setting is used. For
readability reasons, tommycli suggested changing it to a non-unique empty
origin. If we change it, would it still make sense to use url::Origin instead of
GURL inside isPluginAvailable()?

[alexmos, 2016/08/04 05:32:02]

Ah, looking at your https://crrev.com/2208463002, it looks like you'll end up
passing this origin into content settings, which means you'll have to convert
into a GURL anyway, at least until
https://bugs.chromium.org/p/chromium/issues/detail?id=621724 is fixed so that
content settings support url::Origins.  Looking a bit more at isPluginAvailable,
it seems that making it take url::Origins will touch a bunch more unrelated
places, so I'm fine leaving this for a future CL, for whoever is going to work
on 621724.

What do you mean by a non-unique, empty origin?  Looking at url::Origin's
constructor, it will default to a unique origin unless the scheme/host/port are
actually valid.  (FWIW, I think it's fine to use a unique origin to get to
default content settings - I think that's also done in some other content
settings lookups.)

[trizzofo, 2016/08/05 02:04:25]

Yes, I took a better look at url::Origin constructors and you're right. In that
case, we should probably leave it as an unique url::Origin.

       plugins.push_back(plugin);
     }
   }
 
   FrameHostMsg_GetPlugins::WriteReplyParams(reply_msg, plugins);
   Send(reply_msg);
 }
 
 void RenderFrameMessageFilter::OnGetPluginInfo(
     int render_frame_id,
@@ skipping 90 matching lines @@
   net::URLRequestContext* context =
       GetContentClient()->browser()->OverrideRequestContextForURL(
           url, resource_context_);
   if (!context)
     context = request_context_->GetURLRequestContext();
 
   return context;
 }
 
 }  // namespace content