tab_specific_content_settings.h revision dc0f95d653279beabeb9817299e2902918ba123e 
1// Copyright (c) 2010 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef CHROME_BROWSER_TAB_CONTENTS_TAB_SPECIFIC_CONTENT_SETTINGS_H_
6#define CHROME_BROWSER_TAB_CONTENTS_TAB_SPECIFIC_CONTENT_SETTINGS_H_
7#pragma once
8
9#include "base/basictypes.h"
10#include "chrome/browser/geolocation/geolocation_settings_state.h"
11#include "chrome/common/content_settings.h"
12#include "chrome/common/content_settings_types.h"
13#include "content/browser/renderer_host/render_view_host_delegate.h"
14#include "content/browser/tab_contents/navigation_controller.h"
15
16class CannedBrowsingDataAppCacheHelper;
17class CannedBrowsingDataDatabaseHelper;
18class CannedBrowsingDataIndexedDBHelper;
19class CannedBrowsingDataLocalStorageHelper;
20class CookiesTreeModel;
21class Profile;
22
23namespace net {
24class CookieMonster;
25}
26
27class TabSpecificContentSettings
28    : public RenderViewHostDelegate::ContentSettings {
29 public:
30  class Delegate {
31   public:
32    // Invoked when content settings for resources in the tab contents
33    // associated with this TabSpecificContentSettings object were accessed.
34    // |content_was_blocked| is true, if a content settings type was blocked
35    // (as opposed to just accessed). Currently, this parameter is checked in
36    // unit tests only.
37    virtual void OnContentSettingsAccessed(bool content_was_blocked) = 0;
38
39    virtual ~Delegate() {}
40  };
41
42  TabSpecificContentSettings(Delegate* delegate, Profile* profile);
43
44  virtual ~TabSpecificContentSettings() {}
45
46  // Resets the |content_blocked_| and |content_accessed_| arrays, except for
47  // CONTENT_SETTINGS_TYPE_COOKIES related information.
48  void ClearBlockedContentSettingsExceptForCookies();
49
50  // Resets all cookies related information.
51  void ClearCookieSpecificContentSettings();
52
53  // Clears the Geolocation settings.
54  void ClearGeolocationContentSettings();
55
56  // Changes the |content_blocked_| entry for popups.
57  void SetPopupsBlocked(bool blocked);
58
59  // Updates Geolocation settings on navigation.
60  void GeolocationDidNavigate(
61      const NavigationController::LoadCommittedDetails& details);
62
63  // Returns whether a particular kind of content has been blocked for this
64  // page.
65  bool IsContentBlocked(ContentSettingsType content_type) const;
66
67  // Returns true if content blockage was indicated to the user.
68  bool IsBlockageIndicated(ContentSettingsType content_type) const;
69
70  void SetBlockageHasBeenIndicated(ContentSettingsType content_type);
71
72  // Returns whether a particular kind of content has been accessed. Currently
73  // only tracks cookies.
74  bool IsContentAccessed(ContentSettingsType content_type) const;
75
76  const std::set<std::string>& BlockedResourcesForType(
77      ContentSettingsType content_type) const;
78
79  // Returns the GeolocationSettingsState that controls the
80  // geolocation API usage on this page.
81  const GeolocationSettingsState& geolocation_settings_state() const {
82    return geolocation_settings_state_;
83  }
84
85  // Returns a CookiesTreeModel object for the recoreded allowed cookies.
86  CookiesTreeModel* GetAllowedCookiesTreeModel();
87
88  // Returns a CookiesTreeModel object for the recoreded blocked cookies.
89  CookiesTreeModel* GetBlockedCookiesTreeModel();
90
91  bool load_plugins_link_enabled() { return load_plugins_link_enabled_; }
92  void set_load_plugins_link_enabled(bool enabled) {
93    load_plugins_link_enabled_ = enabled;
94  }
95
96  // RenderViewHostDelegate::ContentSettings implementation.
97  virtual void OnContentBlocked(ContentSettingsType type,
98                                const std::string& resource_identifier);
99  virtual void OnCookiesRead(const GURL& url,
100                             const net::CookieList& cookie_list,
101                             bool blocked_by_policy);
102  virtual void OnCookieChanged(const GURL& url,
103                               const std::string& cookie_line,
104                               const net::CookieOptions& options,
105                               bool blocked_by_policy);
106  virtual void OnIndexedDBAccessed(const GURL& url,
107                                   const string16& description,
108                                   bool blocked_by_policy);
109  virtual void OnLocalStorageAccessed(const GURL& url,
110                                      DOMStorageType storage_type,
111                                      bool blocked_by_policy);
112  virtual void OnWebDatabaseAccessed(const GURL& url,
113                                     const string16& name,
114                                     const string16& display_name,
115                                     unsigned long estimated_size,
116                                     bool blocked_by_policy);
117  virtual void OnAppCacheAccessed(const GURL& manifest_url,
118                                  bool blocked_by_policy);
119  virtual void OnGeolocationPermissionSet(const GURL& requesting_frame,
120                                          bool allowed);
121
122 private:
123  class LocalSharedObjectsContainer {
124   public:
125    explicit LocalSharedObjectsContainer(Profile* profile);
126    ~LocalSharedObjectsContainer();
127
128    // Empties the container.
129    void Reset();
130
131    net::CookieMonster* cookies() const { return cookies_; }
132    CannedBrowsingDataAppCacheHelper* appcaches() const {
133      return appcaches_;
134    }
135    CannedBrowsingDataDatabaseHelper* databases() const {
136      return databases_;
137    }
138    CannedBrowsingDataIndexedDBHelper* indexed_dbs() const {
139      return indexed_dbs_;
140    }
141    CannedBrowsingDataLocalStorageHelper* local_storages() const {
142      return local_storages_;
143    }
144    CannedBrowsingDataLocalStorageHelper* session_storages() const {
145      return session_storages_;
146    }
147
148    CookiesTreeModel* GetCookiesTreeModel();
149
150    bool empty() const;
151
152   private:
153    DISALLOW_COPY_AND_ASSIGN(LocalSharedObjectsContainer);
154
155    scoped_refptr<net::CookieMonster> cookies_;
156    scoped_refptr<CannedBrowsingDataAppCacheHelper> appcaches_;
157    scoped_refptr<CannedBrowsingDataDatabaseHelper> databases_;
158    scoped_refptr<CannedBrowsingDataIndexedDBHelper> indexed_dbs_;
159    scoped_refptr<CannedBrowsingDataLocalStorageHelper> local_storages_;
160    scoped_refptr<CannedBrowsingDataLocalStorageHelper> session_storages_;
161  };
162
163  void AddBlockedResource(ContentSettingsType content_type,
164                          const std::string& resource_identifier);
165
166  void OnContentAccessed(ContentSettingsType type);
167
168  // Stores which content setting types actually have blocked content.
169  bool content_blocked_[CONTENT_SETTINGS_NUM_TYPES];
170
171  // Stores if the blocked content was messaged to the user.
172  bool content_blockage_indicated_to_user_[CONTENT_SETTINGS_NUM_TYPES];
173
174  // Stores which content setting types actually were accessed.
175  bool content_accessed_[CONTENT_SETTINGS_NUM_TYPES];
176
177  // Stores the blocked resources for each content type.
178  // Currently only used for plugins.
179  scoped_ptr<std::set<std::string> >
180      blocked_resources_[CONTENT_SETTINGS_NUM_TYPES];
181
182  // Stores the blocked/allowed cookies.
183  LocalSharedObjectsContainer allowed_local_shared_objects_;
184  LocalSharedObjectsContainer blocked_local_shared_objects_;
185
186  // Manages information about Geolocation API usage in this page.
187  GeolocationSettingsState geolocation_settings_state_;
188
189  // Stores whether the user can load blocked plugins on this page.
190  bool load_plugins_link_enabled_;
191
192  Delegate* delegate_;
193
194  DISALLOW_COPY_AND_ASSIGN(TabSpecificContentSettings);
195};
196
197#endif  // CHROME_BROWSER_TAB_CONTENTS_TAB_SPECIFIC_CONTENT_SETTINGS_H_
198