Change PepperFlashBrowserHost to use CookieSettings to get the LSO settings

chrome/browser/renderer_host/pepper/flash_lso_settings_helper.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/renderer_host/pepper/flash_lso_settings_helper.h"
+
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/resource_context.h"
+#include "googleurl/src/gurl.h"
+
+using content::BrowserThread;
+using content::RenderProcessHost;
+using content::ResourceContext;
+
+namespace chrome {
+
+namespace {
+
+const PP_FlashLSORestrictions kDefaultLSORestrictions =
+    PP_FLASHLSORESTRICTIONS_NONE;

[yzshen1, 2012/12/29 02:04:05]

This value is returned on failure. It indicates "no restrictions". Is that
intended?

[raymes, 2012/12/29 03:21:57]

Yes - I actually checked this with bauerb. His response (summarized):
I think defaulting to allow is fine here (in the worst case, we behave like
NPAPI Flash), but I'm looping chrome-privacy in, in case anybody wants to chime
in.

(and nobody chimed in)

+
+}  // namespace
+
+FlashLSOSettingsHelper::FlashLSOSettingsHelper(int render_process_id)
+    : render_process_id_(render_process_id),
+      initialized_(false),
+      resource_context_(NULL) {
+}
+
+FlashLSOSettingsHelper::~FlashLSOSettingsHelper() {
+}
+
+void FlashLSOSettingsHelper::GetLocalDataRestrictions(
+    const GURL& document_url,
+    const GURL& plugin_url,
+    base::Callback<void(PP_FlashLSORestrictions)> callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // Getting the local data restrictions needs to be done on the IO thread,
+  // however it relies on the ResourceContext which can only be accessed from
+  // the UI thread. We lazily initialize |resource_context_| by grabbing the
+  // pointer from the UI thread and then call |GetLocalDataRestrictions| with

[yzshen1, 2012/12/29 02:04:05]

GetLocalDataRestrictions -> GetLocalDataRestrictionsHelper.

[raymes, 2012/12/29 03:21:57]

Done.

+  // it.
+  if (initialized_) {
+    GetLocalDataRestrictionsHelper(document_url, plugin_url, callback,
+                                   resource_context_);
+  } else {
+    BrowserThread::PostTaskAndReplyWithResult(BrowserThread::UI, FROM_HERE,
+        base::Bind(&FlashLSOSettingsHelper::GetResourceContext, this,
+                   render_process_id_),
+        base::Bind(&FlashLSOSettingsHelper::GetLocalDataRestrictionsHelper,
+                   this, document_url, plugin_url, callback));
+  }
+}
+
+void FlashLSOSettingsHelper::GetLocalDataRestrictionsHelper(
+    const GURL& document_url,
+    const GURL& plugin_url,
+    base::Callback<void(PP_FlashLSORestrictions)> callback,
+    ResourceContext* resource_context) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!initialized_) {
+    initialized_ = true;
+    resource_context_ = resource_context;
+  }
+
+  if (!resource_context_ ||
+      !document_url.is_valid() || !plugin_url.is_valid()) {
+    callback.Run(kDefaultLSORestrictions);
+    return;
+  }
+
+  content::ContentBrowserClient* client =
+      content::GetContentClient()->browser();
+  if (!client->AllowPluginLocalDataAccess(document_url, plugin_url,
+                                          resource_context_)) {
+    callback.Run(PP_FLASHLSORESTRICTIONS_BLOCK);
+  } else if (client->AllowPluginLocalDataSessionOnly(plugin_url,
+                                                     resource_context_)) {
+    callback.Run(PP_FLASHLSORESTRICTIONS_IN_MEMORY);
+  } else {
+    callback.Run(PP_FLASHLSORESTRICTIONS_NONE);
+  }
+}
+
+ResourceContext* FlashLSOSettingsHelper::GetResourceContext(
+    int render_process_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  RenderProcessHost* render_process_host = RenderProcessHost::FromID(
+      render_process_id);
+  if (!render_process_host || !render_process_host->GetBrowserContext())
+    return NULL;
+
+  Profile* profile = Profile::FromBrowserContext(
+      render_process_host->GetBrowserContext());
+  ResourceContext* resource_context = profile->GetResourceContext();
+
+  // Register for a notification when the profile is destroyed so that we
+  // don't access the resource context after that.
+  if (registrar_.get()) {
+    // If |registrar_| is already set, we've already registered for a
+    // notification.
+    return resource_context;
+  }
+  registrar_.reset(new content::NotificationRegistrar);
+  registrar_->Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
+                  content::Source<Profile>(profile));
+  // Hold a ref to ourselves until the profile is destroyed so that we always

[yzshen1, 2012/12/29 02:04:05]

Why we want this to be alive for so long?
This helper object is not shared by multiple flash_browser_host objects.

How about posting a task to unregister when the host is dead? (Bind() will
retain a ref, and after un-registration it is likely that ref count will reach
0.)

[raymes, 2012/12/29 03:21:57]

Good idea. Let me know if my change was along the lines of what you were
thinking.

+  // receive the destruction notification.
+  AddRef();
+  return resource_context;
+}
+
+void FlashLSOSettingsHelper::Observe(int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(type == chrome::NOTIFICATION_PROFILE_DESTROYED);
+  // The profile associated with this class has been destroyed. We can now
+  // unregister for notifications (by deleting |registrar_|) and post a task
+  // to clear the resource context so that it is no longer used.
+  registrar_.reset();
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+      base::Bind(&FlashLSOSettingsHelper::ClearResourceContext, this));

[yzshen1, 2012/12/29 02:04:05]

[I haven't checked. Just want to make sure you have considered that.] so the
profile will post a task to the IO thread to destroy the resource context
*after* this, right?
Otherwise we still have a race.

[raymes, 2012/12/29 03:21:57]

Yes - I made sure this is the case.

+  Release();  // Balances the AddRef in GetResourceContext.
+}
+
+void FlashLSOSettingsHelper::ClearResourceContext() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  resource_context_ = NULL;
+}
+
+}  // namespace chrome