Make content::ResourceContext be a real interface like the rest of the Content API (i.e. don't ha...

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 704 matching lines @@
 }
 
 SkBitmap* ChromeContentBrowserClient::GetDefaultFavicon() {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   return rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
 }
 
 bool ChromeContentBrowserClient::AllowAppCache(
     const GURL& manifest_url,
     const GURL& first_party,
-    const content::ResourceContext& context) {
+    content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data =
-      reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   return io_data->GetCookieSettings()->
       IsSettingCookieAllowed(manifest_url, first_party);
 }
 
 bool ChromeContentBrowserClient::AllowGetCookie(
     const GURL& url,
     const GURL& first_party,
     const net::CookieList& cookie_list,
-    const content::ResourceContext& context,
+    content::ResourceContext* context,
     int render_process_id,
     int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data =
-      reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   bool allow = io_data->GetCookieSettings()->
       IsReadingCookieAllowed(url, first_party);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TabSpecificContentSettings::CookiesRead, render_process_id,
                  render_view_id, url, cookie_list, !allow));
   return allow;
 }
 
 bool ChromeContentBrowserClient::AllowSetCookie(
     const GURL& url,
     const GURL& first_party,
     const std::string& cookie_line,
-    const content::ResourceContext& context,
+    content::ResourceContext* context,
     int render_process_id,
     int render_view_id,
     net::CookieOptions* options) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data =
-      reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
-
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   CookieSettings* cookie_settings = io_data->GetCookieSettings();
   bool allow = cookie_settings->IsSettingCookieAllowed(url, first_party);
 
   if (cookie_settings->IsCookieSessionOnly(url))
     options->set_force_session();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TabSpecificContentSettings::CookieChanged, render_process_id,
                  render_view_id, url, cookie_line, *options, !allow));
   return allow;
 }
 
 bool ChromeContentBrowserClient::AllowSaveLocalState(
-    const content::ResourceContext& context) {
+    content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data =
-      reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   return !io_data->clear_local_state_on_exit()->GetValue();
 }
 
 bool ChromeContentBrowserClient::AllowWorkerDatabase(
     const GURL& url,
     const string16& name,
     const string16& display_name,
     unsigned long estimated_size,
-    const content::ResourceContext& context,
+    content::ResourceContext* context,
     const std::vector<std::pair<int, int> >& render_views) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
-      context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   CookieSettings* cookie_settings = io_data->GetCookieSettings();
   bool allow = cookie_settings->IsSettingCookieAllowed(url, url);
 
   // Record access to database for potential display in UI.
   std::vector<std::pair<int, int> >::const_iterator i;
   for (i = render_views.begin(); i != render_views.end(); ++i) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&TabSpecificContentSettings::WebDatabaseAccessed,
                    i->first, i->second, url, name, display_name, !allow));
   }
 
   return allow;
 }
 
 bool ChromeContentBrowserClient::AllowWorkerFileSystem(
     const GURL& url,
-    const content::ResourceContext& context,
+    content::ResourceContext* context,
     const std::vector<std::pair<int, int> >& render_views) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data = reinterpret_cast<ProfileIOData*>(
-      context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   CookieSettings* cookie_settings = io_data->GetCookieSettings();
   bool allow = cookie_settings->IsSettingCookieAllowed(url, url);
 
   // Record access to file system for potential display in UI.
   std::vector<std::pair<int, int> >::const_iterator i;
   for (i = render_views.begin(); i != render_views.end(); ++i) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&TabSpecificContentSettings::FileSystemAccessed,
                    i->first, i->second, url, !allow));
   }
 
   return allow;
 }
 
 net::URLRequestContext*
 ChromeContentBrowserClient::OverrideRequestContextForURL(
-    const GURL& url, const content::ResourceContext& context) {
+    const GURL& url, content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (url.SchemeIs(chrome::kExtensionScheme)) {
-    ProfileIOData* io_data =
-        reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
+    ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
     return io_data->extensions_request_context();
   }
 
   return NULL;
 }
 
 QuotaPermissionContext*
 ChromeContentBrowserClient::CreateQuotaPermissionContext() {
   return new ChromeQuotaPermissionContext();
 }
@@ skipping 118 matching lines @@
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
   service->RequestPermission(
       source_origin, render_process_id, render_view_id, callback_context,
       tab_util::GetWebContentsByID(render_process_id, render_view_id));
 }
 
 WebKit::WebNotificationPresenter::Permission
     ChromeContentBrowserClient::CheckDesktopNotificationPermission(
         const GURL& source_origin,
-        const content::ResourceContext& context,
+        content::ResourceContext* context,
         int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ProfileIOData* io_data =
-      reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
-
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   if (io_data->GetExtensionInfoMap()->SecurityOriginHasAPIPermission(
         source_origin, render_process_id,
         ExtensionAPIPermission::kNotification))
     return WebKit::WebNotificationPresenter::PermissionAllowed;
 
   // Fall back to the regular notification preferences, which works on an
   // origin basis.
   return io_data->GetNotificationService() ?
       io_data->GetNotificationService()->HasPermission(source_origin) :
       WebKit::WebNotificationPresenter::PermissionNotAllowed;
@@ skipping 36 matching lines @@
   Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
   service->CancelDesktopNotification(
       render_process_id, render_view_id, notification_id);
 }
 
 bool ChromeContentBrowserClient::CanCreateWindow(
     const GURL& source_origin,
     WindowContainerType container_type,
-    const content::ResourceContext& context,
+    content::ResourceContext* context,
     int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // If the opener is trying to create a background window but doesn't have
   // the appropriate permission, fail the attempt.
   if (container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
-    ProfileIOData* io_data =
-        reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
+    ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
     return io_data->GetExtensionInfoMap()->SecurityOriginHasAPIPermission(
         source_origin, render_process_id, ExtensionAPIPermission::kBackground);
   }
   return true;
 }
 
 std::string ChromeContentBrowserClient::GetWorkerProcessTitle(
-    const GURL& url, const content::ResourceContext& context) {
+    const GURL& url, content::ResourceContext* context) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Check if it's an extension-created worker, in which case we want to use
   // the name of the extension.
-  ProfileIOData* io_data =
-      reinterpret_cast<ProfileIOData*>(context.GetUserData(NULL));
+  ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
   const Extension* extension =
       io_data->GetExtensionInfoMap()->extensions().GetByID(url.host());
   return extension ? extension->name() : std::string();
 }
 
 void ChromeContentBrowserClient::ResourceDispatcherHostCreated() {
   return g_browser_process->ResourceDispatcherHostCreated();
 }
 
 ui::Clipboard* ChromeContentBrowserClient::GetClipboard() {
@@ skipping 263 matching lines @@
 #if defined(USE_NSS)
 crypto::CryptoModuleBlockingPasswordDelegate*
     ChromeContentBrowserClient::GetCryptoPasswordDelegate(
         const GURL& url) {
   return browser::NewCryptoModuleBlockingDialogDelegate(
       browser::kCryptoModulePasswordKeygen, url.host());
 }
 #endif
 
 }  // namespace chrome