[WIP][POC]

chrome/browser/permissions/permission_context_base.cc

 // Copyright 2014 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/permissions/permission_context_base.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/permissions/permission_request_id.h"
+#include "chrome/browser/permissions/permission_request_impl.h"
+#include "chrome/browser/permissions/permission_request_manager.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/browser/website_settings_registry.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/origin_util.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/permissions/permission_queue_controller.h"
-#else
-#include "chrome/browser/permissions/permission_request_impl.h"
-#include "chrome/browser/permissions/permission_request_manager.h"
 #endif
 
 // static
 const char PermissionContextBase::kPermissionsKillSwitchFieldStudy[] =
     "PermissionsKillSwitch";
 // static
 const char PermissionContextBase::kPermissionsKillSwitchBlockedValue[] =
     "blocked";
 
 PermissionContextBase::PermissionContextBase(
     Profile* profile,
     const content::PermissionType permission_type,
     const ContentSettingsType content_settings_type)
     : profile_(profile),
       permission_type_(permission_type),
       content_settings_type_(content_settings_type),
       weak_factory_(this) {
-#if defined(OS_ANDROID)
-  permission_queue_controller_.reset(new PermissionQueueController(
-      profile_, permission_type_, content_settings_type_));
-#endif
+// #if defined(OS_ANDROID)
+  // TODO: add runtime flag.
+  // permission_queue_controller_.reset(new PermissionQueueController(
+  //     profile_, permission_type_, content_settings_type_));
+// #endif
 }
 
 PermissionContextBase::~PermissionContextBase() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 void PermissionContextBase::RequestPermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
@@ skipping 76 matching lines @@
       ->SetContentSettingDefaultScope(requesting_origin, embedding_origin,
                                       content_settings_type_, std::string(),
                                       CONTENT_SETTING_DEFAULT);
 }
 
 void PermissionContextBase::CancelPermissionRequest(
     content::WebContents* web_contents,
     const PermissionRequestID& id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-#if defined(OS_ANDROID)
-  GetQueueController()->CancelInfoBarRequest(id);
-#else
+// #if defined(OS_ANDROID)
+//   GetQueueController()->CancelInfoBarRequest(id);
+// #else
   PermissionRequest* cancelling = pending_requests_.get(id.ToString());
   if (cancelling != NULL && web_contents != NULL &&
       PermissionRequestManager::FromWebContents(web_contents) != NULL) {
     PermissionRequestManager::FromWebContents(web_contents)
         ->CancelRequest(cancelling);
   }
-#endif
+// #endif
 }
 
 void PermissionContextBase::DecidePermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const BrowserPermissionCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-#if !defined(OS_ANDROID)
+// #if !defined(OS_ANDROID)
+
+LOG(INFO) << "REQUESTING PERMISSION";
   PermissionRequestManager* permission_request_manager =
       PermissionRequestManager::FromWebContents(web_contents);
   // TODO(felt): sometimes |permission_request_manager| is null. This check is
   // meant to prevent crashes. See crbug.com/457091.
   if (!permission_request_manager)
     return;
   std::unique_ptr<PermissionRequest> request_ptr(new PermissionRequestImpl(
           requesting_origin, permission_type_,
           base::Bind(&PermissionContextBase::PermissionDecided,
                      weak_factory_.GetWeakPtr(), id, requesting_origin,
                      embedding_origin, callback),
           base::Bind(&PermissionContextBase::CleanUpRequest,
                      weak_factory_.GetWeakPtr(), id)));
   PermissionRequest* request = request_ptr.get();
 
   bool inserted =
       pending_requests_.add(id.ToString(), std::move(request_ptr)).second;
   DCHECK(inserted) << "Duplicate id " << id.ToString();
   permission_request_manager->AddRequest(request);
-#else
-  GetQueueController()->CreateInfoBarRequest(
-      id, requesting_origin, embedding_origin,
-      base::Bind(&PermissionContextBase::PermissionDecided,
-                 weak_factory_.GetWeakPtr(), id, requesting_origin,
-                 embedding_origin, callback,
-                 // the queue controller takes care of persisting the
-                 // permission
-                 false));
-#endif
+// #else
+//   GetQueueController()->CreateInfoBarRequest(
+//       id, requesting_origin, embedding_origin,
+//       base::Bind(&PermissionContextBase::PermissionDecided,
+//                  weak_factory_.GetWeakPtr(), id, requesting_origin,
+//                  embedding_origin, callback,
+//                  // the queue controller takes care of persisting the
+//                  // permission
+//                  false));
+// #endif
 }
 
 void PermissionContextBase::PermissionDecided(
     const PermissionRequestID& id,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const BrowserPermissionCallback& callback,
     bool persist,
     ContentSetting content_setting) {
 #if !defined(OS_ANDROID)
   // Infobar persistence and its related UMA is tracked on the infobar
   // controller directly.
   if (persist) {
     DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
            content_setting == CONTENT_SETTING_BLOCK);
     if (content_setting == CONTENT_SETTING_ALLOW)
       PermissionUmaUtil::PermissionGranted(permission_type_, requesting_origin);
     else
       PermissionUmaUtil::PermissionDenied(permission_type_, requesting_origin);
   } else {
     DCHECK_EQ(content_setting, CONTENT_SETTING_DEFAULT);
     PermissionUmaUtil::PermissionDismissed(permission_type_, requesting_origin);
   }
 #endif
 
   NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                       persist, content_setting);
 }
 
-#if defined(OS_ANDROID)
-PermissionQueueController* PermissionContextBase::GetQueueController() {
-  return permission_queue_controller_.get();
-}
-#endif
+// #if defined(OS_ANDROID)
+// PermissionQueueController* PermissionContextBase::GetQueueController() {
+//   return permission_queue_controller_.get();
+// }
+// #endif
 
 Profile* PermissionContextBase::profile() const {
   return profile_;
 }
 
 void PermissionContextBase::NotifyPermissionSet(
     const PermissionRequestID& id,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const BrowserPermissionCallback& callback,
@@ skipping 37 matching lines @@
                                       content_setting);
 }
 
 bool PermissionContextBase::IsPermissionKillSwitchOn() const {
   const std::string param = variations::GetVariationParamValue(
       kPermissionsKillSwitchFieldStudy,
       PermissionUtil::GetPermissionString(permission_type_));
 
   return param == kPermissionsKillSwitchBlockedValue;
 }