Wrapping blocked filesystems into TabSpecificContentSettings

chrome/browser/content_settings/tab_specific_content_settings.h

 // Copyright (c) 2010 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.
 
 #ifndef CHROME_BROWSER_CONTENT_SETTINGS_TAB_SPECIFIC_CONTENT_SETTINGS_H_
 #define CHROME_BROWSER_CONTENT_SETTINGS_TAB_SPECIFIC_CONTENT_SETTINGS_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "chrome/browser/geolocation/geolocation_settings_state.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_types.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/tab_contents_observer.h"
 #include "content/common/dom_storage_common.h"
 #include "content/common/notification_observer.h"
 #include "content/common/notification_registrar.h"
 
 class CannedBrowsingDataAppCacheHelper;
 class CannedBrowsingDataDatabaseHelper;
+class CannedBrowsingDataFilesystemHelper;
 class CannedBrowsingDataIndexedDBHelper;
 class CannedBrowsingDataLocalStorageHelper;
 class CookiesTreeModel;
 class TabContents;
 class Profile;
 struct ContentSettings;
 
 namespace net {
 class CookieList;
 class CookieMonster;
 class CookieOptions;
 }
 
 class TabSpecificContentSettings : public TabContentsObserver,
                                    public NotificationObserver {
  public:
-  TabSpecificContentSettings(TabContents* tab);
+  explicit TabSpecificContentSettings(TabContents* tab);
 
   virtual ~TabSpecificContentSettings();
 
   // Returns the object given a render view's id.
   static TabSpecificContentSettings* Get(int render_process_id,
                                          int render_view_id);
 
   // Static methods called on the UI threads.
   // Called when cookies for the given URL were read either from within the
   // current page or while loading it. |blocked_by_policy| should be true, if
@@ skipping 40 matching lines @@
   // Called when a specific indexed db factory in the current page was
   // accessed. If access was blocked due to the user's content settings,
   // |blocked_by_policy| should be true, and this function should invoke
   // OnContentBlocked.
   static void IndexedDBAccessed(int render_process_id,
                                 int render_view_id,
                                 const GURL& url,
                                 const string16& description,
                                 bool blocked_by_policy);
 
+  // Called when a specific file system in the current page was accessed.
+  // If access was blocked dur to the user's content settings,

[Bernhard Bauer, 2011/05/24 19:42:25]

Nit: "due"

[Mike West, 2011/05/25 09:32:45]

Done.

+  // |blocked_by_policy| should be true, and this function should invoke
+  // OnContentBlocked.
+  static void FileSystemAccessed(int render_process_id,
+                                 int render_view_id,
+                                 const GURL& url,
+                                 bool blocked_by_policy);
+
   // Resets the |content_blocked_| and |content_accessed_| arrays, except for
   // CONTENT_SETTINGS_TYPE_COOKIES related information.
   void ClearBlockedContentSettingsExceptForCookies();
 
   // Resets all cookies related information.
   void ClearCookieSpecificContentSettings();
 
   // Clears the Geolocation settings.
   void ClearGeolocationContentSettings();
 
@@ skipping 56 matching lines @@
 
   // These methods are invoked on the UI thread by the static functions above.
   // Public for testing.
   void OnCookiesRead(const GURL& url,
                      const net::CookieList& cookie_list,
                      bool blocked_by_policy);
   void OnCookieChanged(const GURL& url,
                        const std::string& cookie_line,
                        const net::CookieOptions& options,
                        bool blocked_by_policy);
+  void OnFileSystemAccessed(const GURL& url,
+                            bool blocked_by_policy);
   void OnIndexedDBAccessed(const GURL& url,
                            const string16& description,
                            bool blocked_by_policy);
   void OnLocalStorageAccessed(const GURL& url,
                               DOMStorageType storage_type,
                               bool blocked_by_policy);
   void OnWebDatabaseAccessed(const GURL& url,
                              const string16& name,
                              const string16& display_name,
                              bool blocked_by_policy);
   void OnGeolocationPermissionSet(const GURL& requesting_frame,
                                   bool allowed);
 
  private:
   class LocalSharedObjectsContainer {
    public:
     explicit LocalSharedObjectsContainer(Profile* profile);
     ~LocalSharedObjectsContainer();
 
     // Empties the container.
     void Reset();
 
     net::CookieMonster* cookies() const { return cookies_; }
     CannedBrowsingDataAppCacheHelper* appcaches() const {
       return appcaches_;
     }
     CannedBrowsingDataDatabaseHelper* databases() const {
       return databases_;
     }
+    CannedBrowsingDataFilesystemHelper* filesystems() const {
+      return filesystems_;
+    }
     CannedBrowsingDataIndexedDBHelper* indexed_dbs() const {
       return indexed_dbs_;
     }
     CannedBrowsingDataLocalStorageHelper* local_storages() const {
       return local_storages_;
     }
     CannedBrowsingDataLocalStorageHelper* session_storages() const {
       return session_storages_;
     }
 
     CookiesTreeModel* GetCookiesTreeModel();
 
     bool empty() const;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(LocalSharedObjectsContainer);
 
     scoped_refptr<net::CookieMonster> cookies_;
     scoped_refptr<CannedBrowsingDataAppCacheHelper> appcaches_;
     scoped_refptr<CannedBrowsingDataDatabaseHelper> databases_;
+    scoped_refptr<CannedBrowsingDataFilesystemHelper> filesystems_;
     scoped_refptr<CannedBrowsingDataIndexedDBHelper> indexed_dbs_;
     scoped_refptr<CannedBrowsingDataLocalStorageHelper> local_storages_;
     scoped_refptr<CannedBrowsingDataLocalStorageHelper> session_storages_;
   };
 
   void AddBlockedResource(ContentSettingsType content_type,
                           const std::string& resource_identifier);
 
   void OnContentAccessed(ContentSettingsType type);
 
@@ skipping 25 matching lines @@
 
   // Stores whether the user can load blocked plugins on this page.
   bool load_plugins_link_enabled_;
 
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(TabSpecificContentSettings);
 };
 
 #endif  // CHROME_BROWSER_CONTENT_SETTINGS_TAB_SPECIFIC_CONTENT_SETTINGS_H_