chrome/browser/content_settings/permission_context_base.cc

   1 // Copyright 2014 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 #include "chrome/browser/content_settings/permission_context_base.h"
   6
   7 #include "base/logging.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "chrome/browser/content_settings/permission_bubble_request_impl.h"
  10 #include "chrome/browser/content_settings/permission_context_uma_util.h"
  11 #include "chrome/browser/content_settings/permission_queue_controller.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
  14 #include "chrome/common/pref_names.h"
  15 #include "components/content_settings/core/browser/content_settings_utils.h"
  16 #include "components/content_settings/core/browser/host_content_settings_map.h"
  17 #include "components/content_settings/core/common/permission_request_id.h"
  18 #include "content/public/browser/browser_thread.h"
  19 #include "content/public/browser/web_contents.h"
  20
  21 PermissionContextBase::PermissionContextBase(
  22     Profile* profile,
  23     const ContentSettingsType permission_type)
  24     : profile_(profile),
  25       permission_type_(permission_type),
  26       weak_factory_(this) {
  27   permission_queue_controller_.reset(
  28       new PermissionQueueController(profile_, permission_type_));
  29 }
  30
  31 PermissionContextBase::~PermissionContextBase() {
  32   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  33 }
  34
  35 void PermissionContextBase::RequestPermission(
  36     content::WebContents* web_contents,
  37     const PermissionRequestID& id,
  38     const GURL& requesting_frame,
  39     bool user_gesture,
  40     const BrowserPermissionCallback& callback) {
  41   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  42
  43   DecidePermission(web_contents,
  44                    id,
  45                    requesting_frame.GetOrigin(),
  46                    web_contents->GetLastCommittedURL().GetOrigin(),
  47                    user_gesture,
  48                    callback);
  49 }
  50
  51 ContentSetting PermissionContextBase::GetPermissionStatus(
  52     const GURL& requesting_origin,
  53     const GURL& embedding_origin) const {
  54   return profile_->GetHostContentSettingsMap()->GetContentSetting(
  55       requesting_origin, embedding_origin, permission_type_, std::string());
  56 }
  57
  58 void PermissionContextBase::CancelPermissionRequest(
  59     content::WebContents* web_contents,
  60     const PermissionRequestID& id) {
  61   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  62
  63   if (PermissionBubbleManager::Enabled()) {
  64     PermissionBubbleRequest* cancelling =
  65         pending_bubbles_.get(id.ToString());
  66     if (cancelling != NULL && web_contents != NULL &&
  67         PermissionBubbleManager::FromWebContents(web_contents) != NULL) {
  68       PermissionBubbleManager::FromWebContents(web_contents)->
  69           CancelRequest(cancelling);
  70     }
  71     return;
  72   }
  73
  74   GetQueueController()->CancelInfoBarRequest(id);
  75 }
  76
  77 void PermissionContextBase::DecidePermission(
  78     content::WebContents* web_contents,
  79     const PermissionRequestID& id,
  80     const GURL& requesting_origin,
  81     const GURL& embedding_origin,
  82     bool user_gesture,
  83     const BrowserPermissionCallback& callback) {
  84   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  85
  86   if (!requesting_origin.is_valid() || !embedding_origin.is_valid()) {
  87     DVLOG(1)
  88         << "Attempt to use " << content_settings::GetTypeName(permission_type_)
  89         << " from an invalid URL: " << requesting_origin
  90         << "," << embedding_origin
  91         << " (" << content_settings::GetTypeName(permission_type_)
  92         << " is not supported in popups)";
  93     NotifyPermissionSet(id, requesting_origin, embedding_origin,
  94                         callback, false /* persist */, false /* granted */);
  95     return;
  96   }
  97
  98   ContentSetting content_setting =
  99       profile_->GetHostContentSettingsMap()
 100           ->GetContentSettingAndMaybeUpdateLastUsage(
 101               requesting_origin, embedding_origin, permission_type_,
 102               std::string());
 103
 104   switch (content_setting) {
 105     case CONTENT_SETTING_BLOCK:
 106       NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
 107                           false /* persist */, false /* granted */);
 108       return;
 109     case CONTENT_SETTING_ALLOW:
 110       NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
 111                           false /* persist */, true /* granted */);
 112       return;
 113     default:
 114       break;
 115   }
 116
 117   PermissionContextUmaUtil::PermissionRequested(
 118       permission_type_, requesting_origin);
 119
 120   if (PermissionBubbleManager::Enabled()) {
 121     PermissionBubbleManager* bubble_manager =
 122         PermissionBubbleManager::FromWebContents(web_contents);
 123     DCHECK(bubble_manager);
 124     scoped_ptr<PermissionBubbleRequest> request_ptr(
 125         new PermissionBubbleRequestImpl(
 126             requesting_origin, user_gesture, permission_type_,
 127             profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
 128             base::Bind(&PermissionContextBase::PermissionDecided,
 129                        weak_factory_.GetWeakPtr(), id, requesting_origin,
 130                        embedding_origin, callback),
 131             base::Bind(&PermissionContextBase::CleanUpBubble,
 132                        weak_factory_.GetWeakPtr(), id)));
 133     PermissionBubbleRequest* request = request_ptr.get();
 134
 135     bool inserted = pending_bubbles_.add(
 136         id.ToString(), request_ptr.Pass()).second;
 137     DCHECK(inserted) << "Duplicate id " << id.ToString();
 138     bubble_manager->AddRequest(request);
 139     return;
 140   }
 141
 142   // TODO(gbillock): Delete this and the infobar delegate when
 143   // we're using only bubbles. crbug.com/337458
 144   GetQueueController()->CreateInfoBarRequest(
 145       id, requesting_origin, embedding_origin,
 146       base::Bind(&PermissionContextBase::PermissionDecided,
 147                  weak_factory_.GetWeakPtr(), id, requesting_origin,
 148                  embedding_origin, callback,
 149                  // the queue controller takes care of persisting the
 150                  // permission
 151                  false));
 152 }
 153
 154 void PermissionContextBase::PermissionDecided(
 155     const PermissionRequestID& id,
 156     const GURL& requesting_origin,
 157     const GURL& embedding_origin,
 158     const BrowserPermissionCallback& callback,
 159     bool persist,
 160     bool allowed) {
 161   // Infobar persistance and its related UMA is tracked on the infobar
 162   // controller directly.
 163   if (PermissionBubbleManager::Enabled()) {
 164     if (persist) {
 165       if (allowed)
 166         PermissionContextUmaUtil::PermissionGranted(permission_type_,
 167                                                     requesting_origin);
 168       else
 169         PermissionContextUmaUtil::PermissionDenied(permission_type_,
 170                                                    requesting_origin);
 171     } else {
 172       PermissionContextUmaUtil::PermissionDismissed(permission_type_,
 173                                                     requesting_origin);
 174     }
 175   }
 176
 177   NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
 178                       persist, allowed);
 179 }
 180
 181 PermissionQueueController* PermissionContextBase::GetQueueController() {
 182   return permission_queue_controller_.get();
 183 }
 184
 185 Profile* PermissionContextBase::profile() const {
 186   return profile_;
 187 }
 188
 189 void PermissionContextBase::NotifyPermissionSet(
 190     const PermissionRequestID& id,
 191     const GURL& requesting_origin,
 192     const GURL& embedding_origin,
 193     const BrowserPermissionCallback& callback,
 194     bool persist,
 195     bool allowed) {
 196   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 197   if (persist)
 198     UpdateContentSetting(requesting_origin, embedding_origin, allowed);
 199
 200   UpdateTabContext(id, requesting_origin, allowed);
 201   callback.Run(allowed);
 202 }
 203
 204 void PermissionContextBase::CleanUpBubble(const PermissionRequestID& id) {
 205   size_t success = pending_bubbles_.erase(id.ToString());
 206   DCHECK(success == 1) << "Missing request " << id.ToString();
 207 }
 208
 209 void PermissionContextBase::UpdateContentSetting(const GURL& requesting_origin,
 210                                                  const GURL& embedding_origin,
 211                                                  bool allowed) {
 212   DCHECK_EQ(requesting_origin, requesting_origin.GetOrigin());
 213   DCHECK_EQ(embedding_origin, embedding_origin.GetOrigin());
 214   ContentSetting content_setting =
 215       allowed ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
 216   profile_->GetHostContentSettingsMap()->SetContentSetting(
 217       ContentSettingsPattern::FromURLNoWildcard(requesting_origin),
 218       ContentSettingsPattern::FromURLNoWildcard(embedding_origin),
 219       permission_type_, std::string(), content_setting);
 220 }