components/permissions/permissions_client.cc

   1 // Copyright 2020 The Chromium Authors
   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 "components/permissions/permissions_client.h"
   6
   7 #include "base/functional/callback.h"
   8 #include "build/build_config.h"
   9 #include "build/chromeos_buildflags.h"
  10 #include "components/permissions/permission_request_enums.h"
  11 #include "components/permissions/permission_uma_util.h"
  12 #include "content/public/browser/web_contents.h"
  13
  14 #if !BUILDFLAG(IS_ANDROID)
  15 #include "ui/gfx/paint_vector_icon.h"
  16 #endif
  17
  18 namespace permissions {
  19 namespace {
  20 PermissionsClient* g_client = nullptr;
  21 }
  22
  23 PermissionsClient::PermissionsClient() {
  24   DCHECK(!g_client);
  25   g_client = this;
  26 }
  27
  28 PermissionsClient::~PermissionsClient() {
  29   g_client = nullptr;
  30 }
  31
  32 // static
  33 PermissionsClient* PermissionsClient::Get() {
  34   DCHECK(g_client);
  35   return g_client;
  36 }
  37
  38 double PermissionsClient::GetSiteEngagementScore(
  39     content::BrowserContext* browser_context,
  40     const GURL& origin) {
  41   return 0.0;
  42 }
  43
  44 void PermissionsClient::AreSitesImportant(
  45     content::BrowserContext* browser_context,
  46     std::vector<std::pair<url::Origin, bool>>* origins) {
  47   for (auto& entry : *origins)
  48     entry.second = false;
  49 }
  50
  51 #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS_ASH)
  52 bool PermissionsClient::IsCookieDeletionDisabled(
  53     content::BrowserContext* browser_context,
  54     const GURL& origin) {
  55   return false;
  56 }
  57 #endif
  58
  59 void PermissionsClient::GetUkmSourceId(content::BrowserContext* browser_context,
  60                                        content::WebContents* web_contents,
  61                                        const GURL& requesting_origin,
  62                                        GetUkmSourceIdCallback callback) {
  63   std::move(callback).Run(absl::nullopt);
  64 }
  65
  66 IconId PermissionsClient::GetOverrideIconId(RequestType request_type) {
  67 #if BUILDFLAG(IS_ANDROID)
  68   return 0;
  69 #else
  70   return gfx::kNoneIcon;
  71 #endif
  72 }
  73
  74 std::vector<std::unique_ptr<PermissionUiSelector>>
  75 PermissionsClient::CreatePermissionUiSelectors(
  76     content::BrowserContext* browser_context) {
  77   return std::vector<std::unique_ptr<PermissionUiSelector>>();
  78 }
  79
  80 #if !BUILDFLAG(IS_ANDROID)
  81 void PermissionsClient::TriggerPromptHatsSurveyIfEnabled(
  82     content::BrowserContext* context,
  83     permissions::RequestType request_type,
  84     absl::optional<permissions::PermissionAction> action,
  85     permissions::PermissionPromptDisposition prompt_disposition,
  86     permissions::PermissionPromptDispositionReason prompt_disposition_reason,
  87     permissions::PermissionRequestGestureType gesture_type,
  88     absl::optional<base::TimeDelta> prompt_display_duration,
  89     bool is_post_prompt,
  90     const GURL& gurl,
  91     base::OnceCallback<void()> hats_shown_callback_) {}
  92 #endif
  93
  94 void PermissionsClient::OnPromptResolved(
  95     RequestType request_type,
  96     PermissionAction action,
  97     const GURL& origin,
  98     PermissionPromptDisposition prompt_disposition,
  99     PermissionPromptDispositionReason prompt_disposition_reason,
 100     PermissionRequestGestureType gesture_type,
 101     absl::optional<QuietUiReason> quiet_ui_reason,
 102     base::TimeDelta prompt_display_duration,
 103     content::WebContents* web_contents) {}
 104
 105 absl::optional<bool>
 106 PermissionsClient::HadThreeConsecutiveNotificationPermissionDenies(
 107     content::BrowserContext* browser_context) {
 108   return absl::nullopt;
 109 }
 110
 111 absl::optional<url::Origin> PermissionsClient::GetAutoApprovalOrigin() {
 112   return absl::nullopt;
 113 }
 114
 115 absl::optional<bool> PermissionsClient::HasPreviouslyAutoRevokedPermission(
 116     content::BrowserContext* browser_context,
 117     const GURL& origin,
 118     ContentSettingsType permission) {
 119   return absl::nullopt;
 120 }
 121
 122 bool PermissionsClient::CanBypassEmbeddingOriginCheck(
 123     const GURL& requesting_origin,
 124     const GURL& embedding_origin) {
 125   return false;
 126 }
 127
 128 absl::optional<GURL> PermissionsClient::OverrideCanonicalOrigin(
 129     const GURL& requesting_origin,
 130     const GURL& embedding_origin) {
 131   return absl::nullopt;
 132 }
 133
 134 bool PermissionsClient::DoURLsMatchNewTabPage(const GURL& requesting_origin,
 135                                               const GURL& embedding_origin) {
 136   return false;
 137 }
 138
 139 permissions::PermissionIgnoredReason PermissionsClient::DetermineIgnoreReason(
 140     content::WebContents* web_contents) {
 141   return permissions::PermissionIgnoredReason::UNKNOWN;
 142 }
 143
 144 #if BUILDFLAG(IS_ANDROID)
 145 bool PermissionsClient::IsDseOrigin(content::BrowserContext* browser_context,
 146                                     const url::Origin& origin) {
 147   return false;
 148 }
 149
 150 infobars::InfoBarManager* PermissionsClient::GetInfoBarManager(
 151     content::WebContents* web_contents) {
 152   return nullptr;
 153 }
 154
 155 infobars::InfoBar* PermissionsClient::MaybeCreateInfoBar(
 156     content::WebContents* web_contents,
 157     ContentSettingsType type,
 158     base::WeakPtr<PermissionPromptAndroid> prompt) {
 159   return nullptr;
 160 }
 161
 162 std::unique_ptr<PermissionsClient::PermissionMessageDelegate>
 163 PermissionsClient::MaybeCreateMessageUI(
 164     content::WebContents* web_contents,
 165     ContentSettingsType type,
 166     base::WeakPtr<PermissionPromptAndroid> prompt) {
 167   return nullptr;
 168 }
 169
 170 void PermissionsClient::RepromptForAndroidPermissions(
 171     content::WebContents* web_contents,
 172     const std::vector<ContentSettingsType>& content_settings_types,
 173     const std::vector<ContentSettingsType>& filtered_content_settings_types,
 174     const std::vector<std::string>& required_permissions,
 175     const std::vector<std::string>& optional_permissions,
 176     PermissionsUpdatedCallback callback) {
 177   std::move(callback).Run(false);
 178 }
 179
 180 int PermissionsClient::MapToJavaDrawableId(int resource_id) {
 181   return 0;
 182 }
 183 #else
 184 std::unique_ptr<PermissionPrompt> PermissionsClient::CreatePrompt(
 185     content::WebContents* web_contents,
 186     PermissionPrompt::Delegate* delegate) {
 187   return nullptr;
 188 }
 189 #endif
 190
 191 bool PermissionsClient::HasDevicePermission(ContentSettingsType type) const {
 192   return true;
 193 }
 194
 195 bool PermissionsClient::CanRequestDevicePermission(
 196     ContentSettingsType type) const {
 197   return false;
 198 }
 199
 200 favicon::FaviconService* PermissionsClient::GetFaviconService(
 201     content::BrowserContext* browser_context) {
 202   return nullptr;
 203 }
 204
 205 }  // namespace permissions