Improve Mojo permission service and chrome::PermissionManager observing.

content/browser/permissions/permission_service_impl.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 "content/browser/permissions/permission_service_impl.h"
 
 #include "base/bind.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
@@ skipping 18 matching lines @@
 
   NOTREACHED();
   return PermissionType::NUM;
 }
 
 } // anonymous namespace
 
 PermissionServiceImpl::PendingRequest::PendingRequest(
     PermissionType permission,
     const GURL& origin,
-    const mojo::Callback<void(PermissionStatus)>& callback)
+    const PermissionStatusCallback& callback)
     : permission(permission),
       origin(origin),
       callback(callback) {
 }
 
 PermissionServiceImpl::PendingRequest::~PendingRequest() {
   if (!callback.is_null()) {
     callback.Run(PERMISSION_STATUS_ASK);
   }
 }
 
+PermissionServiceImpl::PendingSubscription::PendingSubscription(
+    PermissionType permission,
+    const GURL& origin,
+    const PermissionStatusCallback& callback)
+    : permission(permission),
+      origin(origin),
+      callback(callback) {
+}
+
+PermissionServiceImpl::PendingSubscription::~PendingSubscription() {
+  DCHECK(callback.is_null());
+}
+
 PermissionServiceImpl::PermissionServiceImpl(PermissionServiceContext* context)
     : context_(context),
       weak_factory_(this) {
 }
 
 PermissionServiceImpl::~PermissionServiceImpl() {
+  DCHECK(pending_requests_.IsEmpty());
+  DCHECK(pending_subscriptions_.IsEmpty());
 }
 
 void PermissionServiceImpl::OnConnectionError() {
   context_->ServiceHadConnectionError(this);
   // After that call, |this| will be deleted.
 }
 
 void PermissionServiceImpl::RequestPermission(
     PermissionName permission,
     const mojo::String& origin,
     bool user_gesture,
-    const mojo::Callback<void(PermissionStatus)>& callback) {
+    const PermissionStatusCallback& callback) {
   // This condition is valid if the call is coming from a ChildThread instead of
   // a RenderFrame. Some consumers of the service run in Workers and some in
   // Frames. In the context of a Worker, it is not possible to show a
   // permission prompt because there is no tab. In the context of a Frame, we
   // can. Even if the call comes from a context where it is not possible to show
   // any UI, we want to still return something relevant so the current
   // permission status is returned.
   if (!context_->web_contents()) {
     // There is no way to show a UI so the call will simply return the current
     // permission.
@@ skipping 20 matching lines @@
       user_gesture, // TODO(mlamouri): should be removed (crbug.com/423770)
       base::Bind(&PermissionServiceImpl::OnRequestPermissionResponse,
                  weak_factory_.GetWeakPtr(),
                  request_id));
 }
 
 void PermissionServiceImpl::OnRequestPermissionResponse(
     int request_id,
     PermissionStatus status) {
   PendingRequest* request = pending_requests_.Lookup(request_id);
-  mojo::Callback<void(PermissionStatus)> callback(request->callback);
+  PermissionStatusCallback callback(request->callback);
   request->callback.reset();
   pending_requests_.Remove(request_id);
   callback.Run(status);
 }
 
-void PermissionServiceImpl::CancelPendingRequests() {
+void PermissionServiceImpl::CancelPendingOperations() {
   DCHECK(context_->web_contents());
   DCHECK(context_->GetBrowserContext());
 
   PermissionManager* permission_manager =
       context_->GetBrowserContext()->GetPermissionManager();
   if (!permission_manager)
     return;
 
+  // Cancel pending requests.
   for (RequestsMap::Iterator<PendingRequest> it(&pending_requests_);
        !it.IsAtEnd(); it.Advance()) {
     permission_manager->CancelPermissionRequest(
         it.GetCurrentValue()->permission,
         context_->web_contents(),
         it.GetCurrentKey(),
         it.GetCurrentValue()->origin);
   }
+  pending_requests_.Clear();
 
-  pending_requests_.Clear();
+  // Cancel pending subscriptions.
+  for (SubscriptionsMap::Iterator<PendingSubscription>
+          it(&pending_subscriptions_); !it.IsAtEnd(); it.Advance()) {
+    it.GetCurrentValue()->callback.Run(GetPermissionStatusFromType(
+        it.GetCurrentValue()->permission, it.GetCurrentValue()->origin));
+    it.GetCurrentValue()->callback.reset();
+    permission_manager->UnsubscribePermissionStatusChange(it.GetCurrentKey());
+  }
+  pending_subscriptions_.Clear();
 }
 
 void PermissionServiceImpl::HasPermission(
     PermissionName permission,
     const mojo::String& origin,
-    const mojo::Callback<void(PermissionStatus)>& callback) {
-  DCHECK(context_->GetBrowserContext());
-
+    const PermissionStatusCallback& callback) {
   callback.Run(GetPermissionStatusFromName(permission, GURL(origin)));
 }
 
 void PermissionServiceImpl::RevokePermission(
     PermissionName permission,
     const mojo::String& origin,
-    const mojo::Callback<void(PermissionStatus)>& callback) {
+    const PermissionStatusCallback& callback) {
   GURL origin_url(origin);
   PermissionType permission_type = PermissionNameToPermissionType(permission);
   PermissionStatus status = GetPermissionStatusFromType(permission_type,
                                                         origin_url);
 
   // Resetting the permission should only be possible if the permission is
   // already granted.
   if (status != PERMISSION_STATUS_GRANTED) {
     callback.Run(status);
     return;
   }
 
   ResetPermissionStatus(permission_type, origin_url);
 
   callback.Run(GetPermissionStatusFromType(permission_type, origin_url));
 }
 
 void PermissionServiceImpl::GetNextPermissionChange(
     PermissionName permission,
-    const mojo::String& origin,
+    const mojo::String& mojo_origin,
     PermissionStatus last_known_status,
-    const mojo::Callback<void(PermissionStatus)>& callback) {
+    const PermissionStatusCallback& callback) {
+  GURL origin(mojo_origin);
   PermissionStatus current_status =
-      GetPermissionStatusFromName(permission, GURL(origin));
+      GetPermissionStatusFromName(permission, origin);
   if (current_status != last_known_status) {
     callback.Run(current_status);
     return;
   }
 
   BrowserContext* browser_context = context_->GetBrowserContext();
   DCHECK(browser_context);
   if (!browser_context->GetPermissionManager()) {
     callback.Run(current_status);
     return;
   }
 
   int* subscription_id = new int();
+  PermissionType permission_type = PermissionNameToPermissionType(permission);
 
   GURL embedding_origin = context_->GetEmbeddingOrigin();
   *subscription_id =
       browser_context->GetPermissionManager()->SubscribePermissionStatusChange(
-          PermissionNameToPermissionType(permission),
-          GURL(origin),
+          permission_type,
+          origin,
           // If the embedding_origin is empty, we,ll use the |origin| instead.
-          embedding_origin.is_empty() ? GURL(origin) : embedding_origin,
+          embedding_origin.is_empty() ? origin : embedding_origin,
           base::Bind(&PermissionServiceImpl::OnPermissionStatusChanged,
                      weak_factory_.GetWeakPtr(),
-                     callback,
                      base::Owned(subscription_id)));
+
+  pending_subscriptions_.AddWithID(
+      new PendingSubscription(permission_type, origin, callback),
+                              *subscription_id);
 }
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatusFromName(
     PermissionName permission, const GURL& origin) {
   return GetPermissionStatusFromType(PermissionNameToPermissionType(permission),
                                      origin);
 }
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatusFromType(
     PermissionType type, const GURL& origin) {
@@ skipping 15 matching lines @@
   if (!browser_context->GetPermissionManager())
     return;
 
   // If the embedding_origin is empty we'll use |origin| instead.
   GURL embedding_origin = context_->GetEmbeddingOrigin();
   browser_context->GetPermissionManager()->ResetPermission(
       type, origin, embedding_origin.is_empty() ? origin : embedding_origin);
 }
 
 void PermissionServiceImpl::OnPermissionStatusChanged(
-    const mojo::Callback<void(PermissionStatus)>& callback,
     const int* subscription_id,

[whywhat, 2015/04/01 18:41:17]

why const int* ??

     PermissionStatus status) {
-  callback.Run(status);
+  PendingSubscription* subscription =
+      pending_subscriptions_.Lookup(*subscription_id);
+
+  subscription->callback.Run(status);
 
   BrowserContext* browser_context = context_->GetBrowserContext();
   DCHECK(browser_context);
   if (!browser_context->GetPermissionManager())
     return;
   browser_context->GetPermissionManager()->UnsubscribePermissionStatusChange(
       *subscription_id);
+
+  subscription->callback.reset();
+  pending_subscriptions_.Remove(*subscription_id);
 }
 
 }  // namespace content