Wrapping blocked filesystems into TabSpecificContentSettings

chrome/browser/content_settings/tab_specific_content_settings.cc

 // Copyright (c) 2011 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/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/lazy_instance.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data_database_helper.h"
+#include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/browser/browsing_data_indexed_db_helper.h"
 #include "chrome/browser/browsing_data_local_storage_helper.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/cookies_tree_model.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_delegate.h"
 #include "content/common/notification_service.h"
 #include "content/common/view_messages.h"
 #include "net/base/cookie_monster.h"
+#include "webkit/fileapi/file_system_types.h"
 
 namespace {
 typedef std::list<TabSpecificContentSettings*> TabSpecificList;
 static base::LazyInstance<TabSpecificList> g_tab_specific(
     base::LINKER_INITIALIZED);
 }
 
 bool TabSpecificContentSettings::LocalSharedObjectsContainer::empty() const {
   return cookies_->GetAllCookies().empty() &&
       appcaches_->empty() &&
       databases_->empty() &&

[jochen (gone - plz use gerrit), 2011/05/25 15:54:09]

add filesystem_->empty()

[Mike West, 2011/05/25 16:55:16]

Good catch.

       indexed_dbs_->empty() &&
       local_storages_->empty() &&
       session_storages_->empty();
 }
 
 TabSpecificContentSettings::TabSpecificContentSettings(TabContents* tab)
     : TabContentsObserver(tab),
       allowed_local_shared_objects_(tab->profile()),
       blocked_local_shared_objects_(tab->profile()),
       geolocation_settings_state_(tab->profile()),
@@ skipping 16 matching lines @@
   RenderViewHost* view = RenderViewHost::FromID(
       render_process_id, render_view_id);
   if (!view)
     return NULL;
   // We loop through the tab contents and compare them with |view|, instead of
   // getting the RVH from each tab contents and comparing its IDs because the
   // latter will miss provisional RenderViewHosts.
   for (TabSpecificList::iterator i = g_tab_specific.Get().begin();
        i != g_tab_specific.Get().end(); ++i) {
     if (view->delegate() == (*i)->tab_contents())
-      return (*i);    
+      return (*i);
   }
 
   return NULL;
 }
 
 void TabSpecificContentSettings::CookiesRead(int render_process_id,
                                              int render_view_id,
                                              const GURL& url,
                                              const net::CookieList& cookie_list,
                                              bool blocked_by_policy) {
@@ skipping 39 matching lines @@
 void TabSpecificContentSettings::IndexedDBAccessed(int render_process_id,
                                                    int render_view_id,
                                                    const GURL& url,
                                                    const string16& description,
                                                    bool blocked_by_policy) {
   TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
   if (settings)
     settings->OnIndexedDBAccessed(url, description, blocked_by_policy);
 }
 
+void TabSpecificContentSettings::FileSystemAccessed(int render_process_id,
+                                                    int render_view_id,
+                                                    const GURL& url,
+                                                    bool blocked_by_policy) {
+  TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
+  if (settings)
+    settings->OnFileSystemAccessed(url, blocked_by_policy);
+}
+
 bool TabSpecificContentSettings::IsContentBlocked(
     ContentSettingsType content_type) const {
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by ContentSettingGeolocationImageModel";
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
       << "Notifications settings handled by "
       << "ContentSettingsNotificationsImageModel";
 
   if (content_type == CONTENT_SETTINGS_TYPE_IMAGES ||
       content_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
@@ skipping 117 matching lines @@
 }
 
 void TabSpecificContentSettings::OnIndexedDBAccessed(
     const GURL& url,
     const string16& description,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.indexed_dbs()->AddIndexedDB(
         url, description);
     OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
-  }else {
+  } else {
     allowed_local_shared_objects_.indexed_dbs()->AddIndexedDB(
         url, description);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::OnLocalStorageAccessed(
     const GURL& url,
     DOMStorageType storage_type,
     bool blocked_by_policy) {
@@ skipping 30 matching lines @@
     const GURL& manifest_url, bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
     OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
   } else {
     allowed_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
     OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
+void TabSpecificContentSettings::OnFileSystemAccessed(
+    const GURL& url,
+    bool blocked_by_policy) {
+  if (blocked_by_policy) {
+    blocked_local_shared_objects_.file_systems()->AddFileSystem(url,
+        fileapi::kFileSystemTypeTemporary);
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+  } else {
+    allowed_local_shared_objects_.file_systems()->AddFileSystem(url,
+        fileapi::kFileSystemTypeTemporary);
+    OnContentAccessed(CONTENT_SETTINGS_TYPE_COOKIES);
+  }
+}
 void TabSpecificContentSettings::OnGeolocationPermissionSet(
     const GURL& requesting_origin,
     bool allowed) {
   geolocation_settings_state_.OnGeolocationPermissionSet(requesting_origin,
                                                          allowed);
   NotificationService::current()->Notify(
       NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
       Source<TabContents>(tab_contents()),
       NotificationService::NoDetails());
 }
@@ skipping 113 matching lines @@
         entry_url, tab_contents()->profile()->GetHostContentSettingsMap()->
             GetContentSettings(entry_url)));
   }
 }
 
 TabSpecificContentSettings::LocalSharedObjectsContainer::
     LocalSharedObjectsContainer(Profile* profile)
     : cookies_(new net::CookieMonster(NULL, NULL)),
       appcaches_(new CannedBrowsingDataAppCacheHelper(profile)),
       databases_(new CannedBrowsingDataDatabaseHelper(profile)),
+      file_systems_(new CannedBrowsingDataFileSystemHelper(profile)),
       indexed_dbs_(new CannedBrowsingDataIndexedDBHelper(profile)),
       local_storages_(new CannedBrowsingDataLocalStorageHelper(profile)),
       session_storages_(new CannedBrowsingDataLocalStorageHelper(profile)) {
   cookies_->SetCookieableSchemes(
       net::CookieMonster::kDefaultCookieableSchemes,
       net::CookieMonster::kDefaultCookieableSchemesCount);
   cookies_->SetKeepExpiredCookies();
 }
 
 TabSpecificContentSettings::LocalSharedObjectsContainer::
     ~LocalSharedObjectsContainer() {
 }
 
 void TabSpecificContentSettings::LocalSharedObjectsContainer::Reset() {
   cookies_ = new net::CookieMonster(NULL, NULL);
   cookies_->SetCookieableSchemes(
       net::CookieMonster::kDefaultCookieableSchemes,
       net::CookieMonster::kDefaultCookieableSchemesCount);
   cookies_->SetKeepExpiredCookies();
   appcaches_->Reset();
   databases_->Reset();
+  file_systems_->Reset();
   indexed_dbs_->Reset();
   local_storages_->Reset();
   session_storages_->Reset();
 }
 
 CookiesTreeModel*
 TabSpecificContentSettings::LocalSharedObjectsContainer::GetCookiesTreeModel() {
   return new CookiesTreeModel(cookies_,
                               databases_->Clone(),
                               local_storages_->Clone(),
                               session_storages_->Clone(),
                               appcaches_->Clone(),
                               indexed_dbs_->Clone(),
+                              file_systems_->Clone(),
                               true);
 }