permissions: handle request ids for permissions in permission manager

android_webview/browser/aw_permission_manager.cc

 // Copyright 2015 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 "android_webview/browser/aw_permission_manager.h"
 
 #include <string>
 
 #include "android_webview/browser/aw_browser_permission_request_delegate.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
-#include "base/memory/weak_ptr.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 
 using content::PermissionStatus;
 using content::PermissionType;
 
 namespace android_webview {
 
 class LastRequestResultCache {
  public:
-  LastRequestResultCache() : weak_factory_(this) {}
+  LastRequestResultCache() = default;
 
   void SetResult(PermissionType permission,
                  const GURL& requesting_origin,
                  const GURL& embedding_origin,
                  PermissionStatus status) {
     DCHECK(status == content::PERMISSION_STATUS_GRANTED ||
            status == content::PERMISSION_STATUS_DENIED);
 
     // TODO(ddorwin): We should be denying empty origins at a higher level.
     if (requesting_origin.is_empty() || embedding_origin.is_empty()) {
@@ skipping 70 matching lines @@
 
     if (permission != PermissionType::PROTECTED_MEDIA_IDENTIFIER) {
       // Other permissions are not cached, so nothing to clear.
       return;
     }
 
     std::string key = GetCacheKey(requesting_origin, embedding_origin);
     pmi_result_cache_.erase(key);
   }
 
-  base::WeakPtr<LastRequestResultCache> GetWeakPtr() {
-    return weak_factory_.GetWeakPtr();
-  }
-
  private:
   // Returns a concatenation of the origins to be used as the index.
   // Returns the empty string if either origin is invalid or empty.
   static std::string GetCacheKey(const GURL& requesting_origin,
                                  const GURL& embedding_origin) {
     const std::string& requesting = requesting_origin.spec();
     const std::string& embedding = embedding_origin.spec();
     if (requesting.empty() || embedding.empty())
       return std::string();
     return requesting + "," + embedding;
   }
 
   using StatusMap = base::hash_map<std::string, PermissionStatus>;
   StatusMap pmi_result_cache_;
 
-  base::WeakPtrFactory<LastRequestResultCache> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(LastRequestResultCache);
 };
 
-namespace {
-
-void CallbackPermisisonStatusWrapper(
-    const base::WeakPtr<LastRequestResultCache>& result_cache,
-    const base::Callback<void(PermissionStatus)>& callback,
-    PermissionType permission,
-    const GURL& requesting_origin,
-    const GURL& embedding_origin,
-    bool allowed) {
-  PermissionStatus status = allowed ? content::PERMISSION_STATUS_GRANTED
-                                    : content::PERMISSION_STATUS_DENIED;
-  if (result_cache.get()) {
-    result_cache->SetResult(permission, requesting_origin, embedding_origin,
-                            status);
-  }
-
-  callback.Run(status);
-}
-
-}  // anonymous namespace
+struct AwPermissionManager::PendingRequest {
+  PermissionType permission;
+  GURL requesting_origin;
+  int render_process_id;
+  int render_frame_id;
+};
 
 AwPermissionManager::AwPermissionManager()
-    : content::PermissionManager(), result_cache_(new LastRequestResultCache) {
+  : content::PermissionManager(),
+    result_cache_(new LastRequestResultCache),
+    weak_ptr_factory_(this) {
 }
 
 AwPermissionManager::~AwPermissionManager() {
 }
 
-void AwPermissionManager::RequestPermission(
+int AwPermissionManager::RequestPermission(
     PermissionType permission,
     content::RenderFrameHost* render_frame_host,
-    int request_id,
-    const GURL& origin,
+    const GURL& requesting_origin,
     bool user_gesture,
     const base::Callback<void(PermissionStatus)>& callback) {
   int render_process_id = render_frame_host->GetProcess()->GetID();
   int render_frame_id = render_frame_host->GetRoutingID();
   AwBrowserPermissionRequestDelegate* delegate =
       AwBrowserPermissionRequestDelegate::FromID(render_process_id,
                                                  render_frame_id);
   if (!delegate) {
     DVLOG(0) << "Dropping permission request for "
              << static_cast<int>(permission);
     callback.Run(content::PERMISSION_STATUS_DENIED);
-    return;
+    return kCancelUnsubscribeNoOp;
   }
 
   const GURL& embedding_origin =
       content::WebContents::FromRenderFrameHost(render_frame_host)
           ->GetLastCommittedURL().GetOrigin();
 
+  int request_id = kCancelUnsubscribeNoOp;
   switch (permission) {
     case PermissionType::GEOLOCATION:
+      request_id = AddPendingRequestToMap(render_process_id, render_frame_id,
+          permission, requesting_origin);
       delegate->RequestGeolocationPermission(
-          origin, base::Bind(&CallbackPermisisonStatusWrapper,
-                             result_cache_->GetWeakPtr(), callback, permission,
-                             origin, embedding_origin));
+          requesting_origin,
+          base::Bind(&AwPermissionManager::OnRequestResponse,
+                     weak_ptr_factory_.GetWeakPtr(), request_id,
+                     callback, permission,
+                     requesting_origin, embedding_origin));
       break;
     case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+      request_id = AddPendingRequestToMap(render_process_id, render_frame_id,
+          permission, requesting_origin);
       delegate->RequestProtectedMediaIdentifierPermission(
-          origin, base::Bind(&CallbackPermisisonStatusWrapper,
-                             result_cache_->GetWeakPtr(), callback, permission,
-                             origin, embedding_origin));
+          requesting_origin,
+          base::Bind(&AwPermissionManager::OnRequestResponse,
+                     weak_ptr_factory_.GetWeakPtr(), request_id,
+                     callback, permission,
+                     requesting_origin, embedding_origin));
       break;
     case PermissionType::MIDI_SYSEX:
+      request_id = AddPendingRequestToMap(render_process_id, render_frame_id,
+          permission, requesting_origin);
       delegate->RequestMIDISysexPermission(
-          origin, base::Bind(&CallbackPermisisonStatusWrapper,
-                             result_cache_->GetWeakPtr(), callback, permission,
-                             origin, embedding_origin));
+          requesting_origin,
+          base::Bind(&AwPermissionManager::OnRequestResponse,
+                     weak_ptr_factory_.GetWeakPtr(), request_id,
+                     callback, permission,
+                     requesting_origin, embedding_origin));
       break;
     case PermissionType::AUDIO_CAPTURE:
     case PermissionType::VIDEO_CAPTURE:
     case PermissionType::NOTIFICATIONS:
     case PermissionType::PUSH_MESSAGING:
     case PermissionType::DURABLE_STORAGE:
       NOTIMPLEMENTED() << "RequestPermission is not implemented for "
                        << static_cast<int>(permission);
       callback.Run(content::PERMISSION_STATUS_DENIED);
       break;
     case PermissionType::MIDI:
       callback.Run(content::PERMISSION_STATUS_GRANTED);
       break;
     case PermissionType::NUM:
       NOTREACHED() << "PermissionType::NUM was not expected here.";
       callback.Run(content::PERMISSION_STATUS_DENIED);
       break;
   }
+  return request_id;
 }
 
-void AwPermissionManager::CancelPermissionRequest(
+// static
+void AwPermissionManager::OnRequestResponse(
+    const base::WeakPtr<AwPermissionManager>& manager,
+    int request_id,
+    const base::Callback<void(PermissionStatus)>& callback,
     PermissionType permission,
-    content::RenderFrameHost* render_frame_host,
-    int request_id,
-    const GURL& origin) {
+    const GURL& requesting_origin,
+    const GURL& embedding_origin,

[mlamouri (slow - plz ping), 2015/09/16 14:42:56]

Why do you pass |request_id| with all the other values that are inside the
PendingRequest object? Seems like you could make that function a bit leaner.

[Lalit Maganti, 2015/09/16 16:41:10]

Good point. Fixed.

+    bool allowed) {
+  PermissionStatus status = allowed ? content::PERMISSION_STATUS_GRANTED
+                                    : content::PERMISSION_STATUS_DENIED;
+  if (manager.get()) {
+    manager->pending_requests_.Remove(request_id);
+    manager->result_cache_->SetResult(
+        permission, requesting_origin, embedding_origin, status);
+  }
+  callback.Run(status);
+}
+
+int AwPermissionManager::AddPendingRequestToMap(
+    int render_process_id,
+    int render_frame_id,
+    PermissionType permission,
+    const GURL& requesting_origin) {
+  PendingRequest* request = new PendingRequest();
+  request->render_process_id = render_process_id;
+  request->render_frame_id = render_frame_id;
+  request->permission = permission;
+  request->requesting_origin = requesting_origin;
+  return pending_requests_.Add(request);

[mlamouri (slow - plz ping), 2015/09/16 14:42:56]

Is having that helper method really better than doing:
int request_id = pending_requests_.Add(new PendingRequest(render_process_id,
render_frame_id, permission, request_origin));

Note that you could even pass RenderFrameHost in there instead of the two ids.

[Lalit Maganti, 2015/09/16 16:41:10]

Done.

+}
+
+void AwPermissionManager::CancelPermissionRequest(int request_id) {
+  PendingRequest* pending_request = pending_requests_.Lookup(request_id);
+  if (!pending_request)
+    return;
+
+  content::RenderFrameHost* render_frame_host =
+      content::RenderFrameHost::FromID(pending_request->render_process_id,
+          pending_request->render_frame_id);
+  DCHECK(render_frame_host);
+
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(render_frame_host);
+  DCHECK(web_contents);
+
   // The caller is canceling (presumably) the most recent request. Assuming the
   // request did not complete, the user did not respond to the requset.
   // Thus, assume we do not know the result.
-  const GURL& embedding_origin =
-      content::WebContents::FromRenderFrameHost(render_frame_host)
+  const GURL& embedding_origin = web_contents
           ->GetLastCommittedURL().GetOrigin();
-  result_cache_->ClearResult(permission, origin, embedding_origin);
+  result_cache_->ClearResult(
+      pending_request->permission,
+      pending_request->requesting_origin,
+      embedding_origin);
 
-  int render_process_id = render_frame_host->GetProcess()->GetID();
-  int render_frame_id = render_frame_host->GetRoutingID();
   AwBrowserPermissionRequestDelegate* delegate =
-      AwBrowserPermissionRequestDelegate::FromID(render_process_id,
-                                                 render_frame_id);
-  if (!delegate)
+      AwBrowserPermissionRequestDelegate::FromID(
+          pending_request->render_process_id,
+          pending_request->render_frame_id);
+  if (!delegate) {
+    pending_requests_.Remove(request_id);
     return;
+  }
 
-  switch (permission) {
+  switch (pending_request->permission) {
     case PermissionType::GEOLOCATION:
-      delegate->CancelGeolocationPermissionRequests(origin);
+      delegate->CancelGeolocationPermissionRequests(
+          pending_request->requesting_origin);
       break;
     case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
-      delegate->CancelProtectedMediaIdentifierPermissionRequests(origin);
+      delegate->CancelProtectedMediaIdentifierPermissionRequests(
+          pending_request->requesting_origin);
       break;
     case PermissionType::MIDI_SYSEX:
-      delegate->CancelMIDISysexPermissionRequests(origin);
+      delegate->CancelMIDISysexPermissionRequests(
+          pending_request->requesting_origin);
       break;
     case PermissionType::NOTIFICATIONS:
     case PermissionType::PUSH_MESSAGING:
     case PermissionType::DURABLE_STORAGE:
     case PermissionType::AUDIO_CAPTURE:
     case PermissionType::VIDEO_CAPTURE:
       NOTIMPLEMENTED() << "CancelPermission not implemented for "
-                       << static_cast<int>(permission);
+                       << static_cast<int>(pending_request->permission);
       break;
     case PermissionType::MIDI:
       // There is nothing to cancel so this is simply ignored.
       break;
     case PermissionType::NUM:
       NOTREACHED() << "PermissionType::NUM was not expected here.";
       break;
   }
+
+  pending_requests_.Remove(request_id);
 }
 
 void AwPermissionManager::ResetPermission(PermissionType permission,
                                           const GURL& requesting_origin,
                                           const GURL& embedding_origin) {
   result_cache_->ClearResult(permission, requesting_origin, embedding_origin);
 }
 
 PermissionStatus AwPermissionManager::GetPermissionStatus(
     PermissionType permission,
@@ skipping 14 matching lines @@
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
 }
 
 int AwPermissionManager::SubscribePermissionStatusChange(
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const base::Callback<void(PermissionStatus)>& callback) {
-  return -1;
+  return kCancelUnsubscribeNoOp;
 }
 
 void AwPermissionManager::UnsubscribePermissionStatusChange(
     int subscription_id) {
 }
 
 }  // namespace android_webview