Implement AwPermissionManager::RequestPermissions

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 "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 blink::mojom::PermissionStatus;
 using content::PermissionType;
 
+using RequestPermissionsCallback =
+    base::Callback<void(const std::vector<PermissionStatus>&)>;
+
 namespace android_webview {
 
+namespace {
+
+void PermissionRequestResponseCallbackWrapper(
+    const base::Callback<void(PermissionStatus)>& callback,
+    const std::vector<PermissionStatus>& vector) {
+  DCHECK_EQ(vector.size(), 1ul);
+  callback.Run(vector[0]);
+}
+
+}  // namespace
+
 class LastRequestResultCache {
  public:
   LastRequestResultCache() = default;
 
   void SetResult(PermissionType permission,
                  const GURL& requesting_origin,
                  const GURL& embedding_origin,
                  PermissionStatus status) {
     DCHECK(status == PermissionStatus::GRANTED ||
            status == PermissionStatus::DENIED);
@@ skipping 91 matching lines @@
       return std::string();
     return requesting + "," + embedding;
   }
 
   using StatusMap = base::hash_map<std::string, PermissionStatus>;
   StatusMap pmi_result_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(LastRequestResultCache);
 };
 
-struct AwPermissionManager::PendingRequest {
+class AwPermissionManager::PendingRequest {
  public:
-  PendingRequest(PermissionType permission,
+  PendingRequest(const std::vector<PermissionType> permissions,
                  GURL requesting_origin,
                  GURL embedding_origin,
-                 content::RenderFrameHost* render_frame_host,
-                 const base::Callback<void(PermissionStatus)>& callback)
-    : permission(permission),
-      requesting_origin(requesting_origin),
-      embedding_origin(embedding_origin),
-      render_process_id(render_frame_host->GetProcess()->GetID()),
-      render_frame_id(render_frame_host->GetRoutingID()),
-      callback(callback) {
+                 int render_process_id,
+                 int render_frame_id,
+                 const RequestPermissionsCallback callback)
+      : permissions(permissions),
+        requesting_origin(requesting_origin),
+        embedding_origin(embedding_origin),
+        render_process_id(render_process_id),
+        render_frame_id(render_frame_id),
+        callback(callback),
+        results(permissions.size(), PermissionStatus::DENIED),
+        cancelled_(false) {
+    for (size_t i = 0; i < permissions.size(); ++i)
+      permission_index_map_.insert(std::make_pair(permissions[i], i));
   }
 
   ~PendingRequest() = default;
 
-  PermissionType permission;
+  void SetPermissionStatus(PermissionType type, PermissionStatus status) {
+    auto result = permission_index_map_.find(type);
+    if (result == permission_index_map_.end()) {
+      NOTREACHED();
+      return;
+    }
+    DCHECK(!IsComplete());
+    results[result->second] = status;
+    resolved_permissions_.insert(type);
+  }
+
+  PermissionStatus GetPermissionStatus(PermissionType type) {
+    auto result = permission_index_map_.find(type);
+    if (result == permission_index_map_.end()) {
+      NOTREACHED();
+      return PermissionStatus::DENIED;
+    }
+    return results[result->second];
+  }
+
+  bool HasPermissionType(PermissionType type) {
+    return permission_index_map_.find(type) != permission_index_map_.end();
+  }
+
+  bool IsComplete() const {
+    return results.size() == resolved_permissions_.size();
+  }
+
+  bool IsComplete(PermissionType type) const {
+    return resolved_permissions_.count(type) != 0;
+  }
+
+  void Cancel() { cancelled_ = true; }
+
+  bool IsCancelled() const { return cancelled_; }
+
+  std::vector<PermissionType> permissions;
   GURL requesting_origin;
   GURL embedding_origin;
   int render_process_id;
   int render_frame_id;
-  base::Callback<void(PermissionStatus)> callback;
+  RequestPermissionsCallback callback;
+  std::vector<PermissionStatus> results;
+
+ private:
+  std::map<PermissionType, size_t> permission_index_map_;
+  std::set<PermissionType> resolved_permissions_;
+  bool cancelled_;
 };
 
 AwPermissionManager::AwPermissionManager()
   : content::PermissionManager(),
     result_cache_(new LastRequestResultCache),
     weak_ptr_factory_(this) {
 }
 
 AwPermissionManager::~AwPermissionManager() {
+  CancelPermissionRequests();
 }
 
 int AwPermissionManager::RequestPermission(
     PermissionType permission,
     content::RenderFrameHost* render_frame_host,
     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(PermissionStatus::DENIED);
-    return kNoPendingOperation;
-  }
-
-  // Do not delegate any requests which are already pending.
-  bool should_delegate_request = true;
-  for (PendingRequestsMap::Iterator<PendingRequest> it(&pending_requests_);
-       !it.IsAtEnd(); it.Advance()) {
-    if (permission == it.GetCurrentValue()->permission) {
-      should_delegate_request = false;
-      break;
-    }
-  }
-
-  const GURL& embedding_origin =
-      content::WebContents::FromRenderFrameHost(render_frame_host)
-          ->GetLastCommittedURL().GetOrigin();
-
-  int request_id = kNoPendingOperation;
-  switch (permission) {
-    case PermissionType::GEOLOCATION:
-      request_id = pending_requests_.Add(new PendingRequest(
-          permission, requesting_origin,
-          embedding_origin, render_frame_host,
-          callback));
-      if (should_delegate_request) {
-        delegate->RequestGeolocationPermission(
-            requesting_origin,
-            base::Bind(&OnRequestResponse,
-                       weak_ptr_factory_.GetWeakPtr(), request_id,
-                       callback));
-      }
-      break;
-    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
-      request_id = pending_requests_.Add(new PendingRequest(
-          permission, requesting_origin,
-          embedding_origin, render_frame_host,
-          callback));
-      if (should_delegate_request) {
-        delegate->RequestProtectedMediaIdentifierPermission(
-            requesting_origin,
-            base::Bind(&OnRequestResponse,
-                       weak_ptr_factory_.GetWeakPtr(), request_id,
-                       callback));
-      }
-      break;
-    case PermissionType::MIDI_SYSEX:
-      request_id = pending_requests_.Add(new PendingRequest(
-          permission, requesting_origin,
-          embedding_origin, render_frame_host,
-          callback));
-      if (should_delegate_request) {
-        delegate->RequestMIDISysexPermission(
-            requesting_origin,
-            base::Bind(&OnRequestResponse,
-                       weak_ptr_factory_.GetWeakPtr(), request_id,
-                       callback));
-      }
-      break;
-    case PermissionType::AUDIO_CAPTURE:
-    case PermissionType::VIDEO_CAPTURE:
-    case PermissionType::NOTIFICATIONS:
-    case PermissionType::PUSH_MESSAGING:
-    case PermissionType::DURABLE_STORAGE:
-    case PermissionType::BACKGROUND_SYNC:
-      NOTIMPLEMENTED() << "RequestPermission is not implemented for "
-                       << static_cast<int>(permission);
-      callback.Run(PermissionStatus::DENIED);
-      break;
-    case PermissionType::MIDI:
-      callback.Run(PermissionStatus::GRANTED);
-      break;
-    case PermissionType::NUM:
-      NOTREACHED() << "PermissionType::NUM was not expected here.";
-      callback.Run(PermissionStatus::DENIED);
-      break;
-  }
-  return request_id;
+  return RequestPermissions(
+      std::vector<PermissionType>(1, permission), render_frame_host,
+      requesting_origin, user_gesture,
+      base::Bind(&PermissionRequestResponseCallbackWrapper, callback));
 }
 
 int AwPermissionManager::RequestPermissions(
     const std::vector<PermissionType>& permissions,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     bool user_gesture,
-    const base::Callback<void(
-        const std::vector<PermissionStatus>&)>& callback) {
-  NOTIMPLEMENTED() << "RequestPermissions has not been implemented in WebView";
-
-  std::vector<PermissionStatus> result(permissions.size());
-  const GURL& embedding_origin =
-      content::WebContents::FromRenderFrameHost(render_frame_host)
-          ->GetLastCommittedURL().GetOrigin();
-
-  for (PermissionType type : permissions) {
-    result.push_back(GetPermissionStatus(
-        type, requesting_origin, embedding_origin));
-  }
-
-  callback.Run(result);
-  return kNoPendingOperation;
+    const base::Callback<void(const std::vector<PermissionStatus>&)>&
+        callback) {
+  if (permissions.empty()) {
+    callback.Run(std::vector<PermissionStatus>());
+    return kNoPendingOperation;
+  }
+
+  const GURL& embedding_origin = LastCommittedOrigin(render_frame_host);
+
+  PendingRequest* pending_request =
+      new PendingRequest(permissions, requesting_origin, embedding_origin,
+                         GetRenderProcessID(render_frame_host),
+                         GetRenderFrameID(render_frame_host), callback);
+  std::vector<bool> should_delegate_requests =
+      std::vector<bool>(permissions.size());
+  for (size_t i = 0; i < permissions.size(); ++i) {
+    bool should_delegate_request = true;
+    for (PendingRequestsMap::Iterator<PendingRequest> it(&pending_requests_);
+         !it.IsAtEnd(); it.Advance()) {
+      if (it.GetCurrentValue()->HasPermissionType(permissions[i])) {
+        if (!it.GetCurrentValue()->IsComplete(permissions[i])) {
+          should_delegate_request = false;

[Tobias Sargeant, 2016/07/25 13:29:53]

Should this also be dependent on a requesting_origin match?

[Takashi Toyoshima, 2016/07/26 04:58:30]

No.

If there is a running request for the same permission type, we should avoid to
make a new request for the same type simultaneously.

This is because each delegate method for the permissions can accept only one
running request IIUC, and the next request should wait until the previous one is
resolved.

In OnRequestResponse(), MayRequestNextPermission() is called. It checks all
pending requests, and if a request for the same type that is just resolved
exists, make a new delegate call for it.

This case is covered by multiple tests, e.g. ComplicatedRequestScenario2.

+        } else {
+          if (it.GetCurrentValue()->requesting_origin == requesting_origin) {
+            should_delegate_request = false;
+            pending_request->SetPermissionStatus(
+                permissions[i],
+                it.GetCurrentValue()->GetPermissionStatus(permissions[i]));
+          }
+        }
+      }
+    }
+    should_delegate_requests[i] = should_delegate_request;
+  }
+
+  int request_id = pending_requests_.Add(pending_request);
+
+  for (size_t i = 0; i < permissions.size(); ++i) {
+    if (!should_delegate_requests[i])
+      continue;
+    RequestPermissionInternal(permissions[i], request_id);
+  }
+
+  // If delegate resolve the permission synchronously, all requests could be
+  // already resolved here.
+  if (!pending_requests_.Lookup(request_id))
+    return kNoPendingOperation;
+
+  // If requests are resolved without calling delegate functions, e.g.
+  // PermissionType::MIDI is permitted within the previous for-loop, all
+  // requests could be already resolved, but still in the |pending_requests_|
+  // without invoking the callback.
+  if (pending_request->IsComplete()) {
+    std::vector<PermissionStatus> results = pending_request->results;
+    pending_requests_.Remove(request_id);
+    callback.Run(results);
+    return kNoPendingOperation;
+  }
+
+  return request_id;
 }
 
 // static
 void AwPermissionManager::OnRequestResponse(
     const base::WeakPtr<AwPermissionManager>& manager,
     int request_id,
-    const base::Callback<void(PermissionStatus)>& callback,
+    PermissionType permission,
     bool allowed) {
+  // All delegate functions should be cancelled when the manager runs
+  // destructor. Therefore |manager| should be always valid here.
+  DCHECK(manager);
+
   PermissionStatus status =
       allowed ? PermissionStatus::GRANTED : PermissionStatus::DENIED;
-  if (manager.get()) {
-    PendingRequest* pending_request =
-        manager->pending_requests_.Lookup(request_id);
-
-    for (PendingRequestsMap::Iterator<PendingRequest> it(
-            &manager->pending_requests_);
-         !it.IsAtEnd(); it.Advance()) {
-      if (pending_request->permission == it.GetCurrentValue()->permission &&
-          it.GetCurrentKey() != request_id) {
-        it.GetCurrentValue()->callback.Run(status);
-        manager->pending_requests_.Remove(it.GetCurrentKey());
-      }
-    }
-
-    manager->result_cache_->SetResult(
-        pending_request->permission,
-        pending_request->requesting_origin,
-        pending_request->embedding_origin,
-        status);
-    manager->pending_requests_.Remove(request_id);
-  }
-  callback.Run(status);
+  PendingRequest* pending_request =
+      manager->pending_requests_.Lookup(request_id);
+
+  manager->result_cache_->SetResult(permission,
+                                    pending_request->requesting_origin,
+                                    pending_request->embedding_origin, status);
+
+  std::vector<int> complete_request_ids;
+  std::vector<std::pair<const RequestPermissionsCallback,
+                        std::vector<PermissionStatus>>>
+      complete_request_pairs;
+  for (PendingRequestsMap::Iterator<PendingRequest> it(
+           &manager->pending_requests_);
+       !it.IsAtEnd(); it.Advance()) {
+    if (!it.GetCurrentValue()->HasPermissionType(permission) ||
+        it.GetCurrentValue()->requesting_origin !=
+            pending_request->requesting_origin) {
+      continue;
+    }
+    it.GetCurrentValue()->SetPermissionStatus(permission, status);
+    if (it.GetCurrentValue()->IsComplete()) {
+      complete_request_ids.push_back(it.GetCurrentKey());
+      if (!it.GetCurrentValue()->IsCancelled()) {
+        complete_request_pairs.push_back(std::make_pair(
+            it.GetCurrentValue()->callback, it.GetCurrentValue()->results));
+      }
+    }
+  }
+  for (auto id : complete_request_ids)
+    manager->pending_requests_.Remove(id);
+  for (auto pair : complete_request_pairs)
+    pair.first.Run(pair.second);
+
+  manager->MayRequestNextPermission(permission);
 }
 
 void AwPermissionManager::CancelPermissionRequest(int request_id) {
   PendingRequest* pending_request = pending_requests_.Lookup(request_id);
-  if (!pending_request)
+  if (!pending_request || pending_request->IsCancelled())
     return;
-
-  content::RenderFrameHost* render_frame_host =
-      content::RenderFrameHost::FromID(pending_request->render_process_id,
-          pending_request->render_frame_id);
-  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 = web_contents
-          ->GetLastCommittedURL().GetOrigin();
-  result_cache_->ClearResult(
-      pending_request->permission,
-      pending_request->requesting_origin,
-      embedding_origin);
-
-  AwBrowserPermissionRequestDelegate* delegate =
-      AwBrowserPermissionRequestDelegate::FromID(
-          pending_request->render_process_id,
-          pending_request->render_frame_id);
+  pending_request->Cancel();
+
+  const GURL& embedding_origin = pending_request->embedding_origin;
+  const GURL& requesting_origin = pending_request->requesting_origin;
+  for (auto permission : pending_request->permissions)
+    result_cache_->ClearResult(permission, requesting_origin, embedding_origin);
+
+  AwBrowserPermissionRequestDelegate* delegate = GetDelegate(
+      pending_request->render_process_id, pending_request->render_frame_id);
   if (!delegate) {
     pending_requests_.Remove(request_id);
     return;
   }
 
-  switch (pending_request->permission) {
-    case PermissionType::GEOLOCATION:
-      delegate->CancelGeolocationPermissionRequests(
-          pending_request->requesting_origin);
-      break;
-    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
-      delegate->CancelProtectedMediaIdentifierPermissionRequests(
-          pending_request->requesting_origin);
-      break;
-    case PermissionType::MIDI_SYSEX:
-      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:
-    case PermissionType::BACKGROUND_SYNC:
-      NOTIMPLEMENTED() << "CancelPermission not implemented for "
-                       << 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);
+  for (auto permission : pending_request->permissions) {
+    // If the permission was already resolved, we do not need to cancel it.
+    if (pending_request->IsComplete(permission))
+      continue;
+
+    // If another pending_request waits for the same permission being resolved,
+    // we should not cancel the request.
+    bool should_not_cancel_ = false;
+    for (PendingRequestsMap::Iterator<PendingRequest> it(&pending_requests_);
+         !it.IsAtEnd(); it.Advance()) {
+      if (it.GetCurrentValue() == pending_request ||
+          it.GetCurrentValue()->requesting_origin != requesting_origin) {
+        continue;
+      }
+      // We need to check if |permission| was resolved for the current request
+      // in addition to the |pending_request|. This is because |permission|
+      // might be resolved for the current request before |pending_request| was
+      // issued.
+      if (it.GetCurrentValue()->HasPermissionType(permission) &&
+          !it.GetCurrentValue()->IsComplete(permission)) {
+        should_not_cancel_ = true;
+        break;
+      }
+    }
+    if (should_not_cancel_)
+      continue;
+
+    switch (permission) {
+      case PermissionType::GEOLOCATION:
+        delegate->CancelGeolocationPermissionRequests(requesting_origin);
+        break;
+      case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+        delegate->CancelProtectedMediaIdentifierPermissionRequests(
+            requesting_origin);
+        break;
+      case PermissionType::MIDI_SYSEX:
+        delegate->CancelMIDISysexPermissionRequests(requesting_origin);
+        break;
+      case PermissionType::NOTIFICATIONS:
+      case PermissionType::PUSH_MESSAGING:
+      case PermissionType::DURABLE_STORAGE:
+      case PermissionType::AUDIO_CAPTURE:
+      case PermissionType::VIDEO_CAPTURE:
+      case PermissionType::BACKGROUND_SYNC:
+        NOTIMPLEMENTED() << "CancelPermission not implemented for "
+                         << static_cast<int>(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_request->SetPermissionStatus(permission, PermissionStatus::DENIED);
+    MayRequestNextPermission(permission);
+  }
+
+  // If there are still active requests, we should not remove request_id here,
+  // but just do not invoke a relevant callback when the request is resolved in
+  // OnRequestResponse().
+  if (pending_request->IsComplete())
+    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 21 matching lines @@
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const base::Callback<void(PermissionStatus)>& callback) {
   return kNoPendingOperation;
 }
 
 void AwPermissionManager::UnsubscribePermissionStatusChange(
     int subscription_id) {
 }
 
+void AwPermissionManager::CancelPermissionRequests() {
+  std::vector<int> request_ids;
+  for (PendingRequestsMap::Iterator<PendingRequest> it(&pending_requests_);
+       !it.IsAtEnd(); it.Advance()) {
+    request_ids.push_back(it.GetCurrentKey());
+  }
+  for (auto request_id : request_ids)
+    CancelPermissionRequest(request_id);
+  DCHECK(pending_requests_.IsEmpty());
+}
+
+bool AwPermissionManager::RequestPermissionInternal(

[Tobias Sargeant, 2016/07/25 13:29:53]

Couldn't this method just take request and delegate as parameters, rather than
looking them up each time?

[Takashi Toyoshima, 2016/07/26 04:58:30]

Done.

+    PermissionType permission,
+    int request_id) {
+  PendingRequest* request = pending_requests_.Lookup(request_id);
+  DCHECK(request);
+  DCHECK(!request->IsComplete(permission));
+
+  AwBrowserPermissionRequestDelegate* delegate =
+      GetDelegate(request->render_process_id, request->render_frame_id);
+  if (!delegate) {
+    DVLOG(0) << "Dropping permissions request for "
+             << static_cast<int>(permission);
+    request->SetPermissionStatus(permission, PermissionStatus::DENIED);
+    return false;
+  }
+
+  switch (permission) {
+    case PermissionType::GEOLOCATION:
+      delegate->RequestGeolocationPermission(
+          request->requesting_origin,
+          base::Bind(&OnRequestResponse, weak_ptr_factory_.GetWeakPtr(),
+                     request_id, permission));
+      break;
+    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+      delegate->RequestProtectedMediaIdentifierPermission(
+          request->requesting_origin,
+          base::Bind(&OnRequestResponse, weak_ptr_factory_.GetWeakPtr(),
+                     request_id, permission));
+      break;
+    case PermissionType::MIDI_SYSEX:
+      delegate->RequestMIDISysexPermission(
+          request->requesting_origin,
+          base::Bind(&OnRequestResponse, weak_ptr_factory_.GetWeakPtr(),
+                     request_id, permission));
+      break;
+    case PermissionType::AUDIO_CAPTURE:
+    case PermissionType::VIDEO_CAPTURE:
+    case PermissionType::NOTIFICATIONS:
+    case PermissionType::PUSH_MESSAGING:
+    case PermissionType::DURABLE_STORAGE:
+    case PermissionType::BACKGROUND_SYNC:
+      NOTIMPLEMENTED() << "RequestPermissions is not implemented for "
+                       << static_cast<int>(permission);
+      request->SetPermissionStatus(permission, PermissionStatus::DENIED);
+      return false;
+    case PermissionType::MIDI:
+      request->SetPermissionStatus(permission, PermissionStatus::GRANTED);
+      return false;
+    case PermissionType::NUM:
+      NOTREACHED() << "PermissionType::NUM was not expected here.";
+      request->SetPermissionStatus(permission, PermissionStatus::DENIED);
+      return false;
+  }
+  return true;
+}
+
+void AwPermissionManager::MayRequestNextPermission(PermissionType permission) {
+  for (PendingRequestsMap::Iterator<PendingRequest> it(&pending_requests_);
+       !it.IsAtEnd(); it.Advance()) {
+    if (it.GetCurrentValue()->IsCancelled() ||
+        !it.GetCurrentValue()->HasPermissionType(permission) ||
+        it.GetCurrentValue()->IsComplete(permission)) {
+      continue;
+    }
+    if (RequestPermissionInternal(permission, it.GetCurrentKey()))
+      break;
+  }
+}
+
+int AwPermissionManager::GetRenderProcessID(
+    content::RenderFrameHost* render_frame_host) {
+  return render_frame_host->GetProcess()->GetID();
+}
+
+int AwPermissionManager::GetRenderFrameID(
+    content::RenderFrameHost* render_frame_host) {
+  return render_frame_host->GetRoutingID();
+}
+
+GURL AwPermissionManager::LastCommittedOrigin(
+    content::RenderFrameHost* render_frame_host) {
+  return content::WebContents::FromRenderFrameHost(render_frame_host)
+      ->GetLastCommittedURL().GetOrigin();
+}
+
+AwBrowserPermissionRequestDelegate* AwPermissionManager::GetDelegate(
+    int render_process_id, int render_frame_id) {
+  return AwBrowserPermissionRequestDelegate::FromID(render_process_id,
+                                                    render_frame_id);
+}
+
 }  // namespace android_webview