Switch PermissionStatus events to an observer model.

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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 
 using blink::mojom::PermissionDescriptorPtr;
 using blink::mojom::PermissionName;
+using blink::mojom::PermissionObserverPtr;
 using blink::mojom::PermissionStatus;
 
 namespace content {
 
 namespace {
 
 PermissionType PermissionDescriptorToPermissionType(
     const PermissionDescriptorPtr& descriptor) {
   switch (descriptor->name) {
     case PermissionName::GEOLOCATION:
@@ skipping 44 matching lines @@
 }
 
 PermissionServiceImpl::PendingRequest::~PendingRequest() {
   if (callback.is_null())
     return;
 
   std::vector<PermissionStatus> result(request_count, PermissionStatus::DENIED);
   callback.Run(result);
 }
 
-PermissionServiceImpl::PendingSubscription::PendingSubscription(
-    PermissionType permission,
-    const url::Origin& origin,
-    const PermissionStatusCallback& callback)
-    : id(-1), permission(permission), origin(origin), callback(callback) {}
-
-PermissionServiceImpl::PendingSubscription::~PendingSubscription() {
-  if (!callback.is_null())
-    callback.Run(PermissionStatus::ASK);
-}
-
 PermissionServiceImpl::PermissionServiceImpl(
     PermissionServiceContext* context,
     mojo::InterfaceRequest<blink::mojom::PermissionService> request)
     : context_(context),
       binding_(this, std::move(request)),
       weak_factory_(this) {
   binding_.set_connection_error_handler(
       base::Bind(&PermissionServiceImpl::OnConnectionError,
                  base::Unretained(this)));
 }
@@ skipping 114 matching lines @@
   if (!permission_manager)
     return;
 
   // Cancel pending requests.
   for (RequestsMap::Iterator<PendingRequest> it(&pending_requests_);
        !it.IsAtEnd(); it.Advance()) {
     permission_manager->CancelPermissionRequest(
         it.GetCurrentValue()->id);
   }
   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.GetCurrentValue()->id);
-  }
-  pending_subscriptions_.Clear();
 }
 
 void PermissionServiceImpl::HasPermission(
     PermissionDescriptorPtr permission,
     const url::Origin& origin,
     const PermissionStatusCallback& callback) {
   callback.Run(GetPermissionStatus(permission, origin));
 }
 
 void PermissionServiceImpl::RevokePermission(
@@ skipping 10 matching lines @@
   if (status != PermissionStatus::GRANTED) {
     callback.Run(status);
     return;
   }
 
   ResetPermissionStatus(permission_type, origin);
 
   callback.Run(GetPermissionStatusFromType(permission_type, origin));
 }
 
-void PermissionServiceImpl::GetNextPermissionChange(
+void PermissionServiceImpl::AddPermissionObserver(
     PermissionDescriptorPtr permission,
     const url::Origin& origin,
     PermissionStatus last_known_status,
-    const PermissionStatusCallback& callback) {
+    PermissionObserverPtr observer) {
   PermissionStatus current_status = GetPermissionStatus(permission, origin);
   if (current_status != last_known_status) {
-    callback.Run(current_status);
-    return;
+    observer->OnPermissionStatusChange(current_status);
+    last_known_status = current_status;
   }
 
   BrowserContext* browser_context = context_->GetBrowserContext();
   DCHECK(browser_context);
-  if (!browser_context->GetPermissionManager()) {
-    callback.Run(current_status);
+  if (!browser_context->GetPermissionManager())
     return;
-  }
 
-  PermissionType permission_type =
-      PermissionDescriptorToPermissionType(permission);
-
-  // We need to pass the id of PendingSubscription in pending_subscriptions_
-  // to the callback but SubscribePermissionStatusChange() will also return an
-  // id which is different.
-  auto subscription =
-      base::MakeUnique<PendingSubscription>(permission_type, origin, callback);
-  PendingSubscription* subscription_raw = subscription.get();
-  int pending_subscription_id =
-      pending_subscriptions_.Add(std::move(subscription));
-
-  GURL requesting_origin(origin.Serialize());
-  GURL embedding_origin = context_->GetEmbeddingOrigin();
-  subscription_raw->id =
-      browser_context->GetPermissionManager()->SubscribePermissionStatusChange(
-          permission_type, requesting_origin,
-          // If the embedding_origin is empty, we,ll use the |origin| instead.
-          embedding_origin.is_empty() ? requesting_origin : embedding_origin,
-          base::Bind(&PermissionServiceImpl::OnPermissionStatusChanged,
-                     weak_factory_.GetWeakPtr(), pending_subscription_id));
+  context_->CreateSubscription(PermissionDescriptorToPermissionType(permission),
+                               origin, std::move(observer));
 }
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatus(
     const PermissionDescriptorPtr& permission,
     const url::Origin& origin) {
   return GetPermissionStatusFromType(
       PermissionDescriptorToPermissionType(permission), origin);
 }
 
 PermissionStatus PermissionServiceImpl::GetPermissionStatusFromType(
@@ skipping 20 matching lines @@
     return;
 
   GURL requesting_origin(origin.Serialize());
   // If the embedding_origin is empty we'll use |origin| instead.
   GURL embedding_origin = context_->GetEmbeddingOrigin();
   browser_context->GetPermissionManager()->ResetPermission(
       type, requesting_origin,
       embedding_origin.is_empty() ? requesting_origin : embedding_origin);
 }
 
-void PermissionServiceImpl::OnPermissionStatusChanged(
-    int pending_subscription_id,
-    PermissionStatus status) {
-  PendingSubscription* subscription =
-      pending_subscriptions_.Lookup(pending_subscription_id);
-
-  BrowserContext* browser_context = context_->GetBrowserContext();
-  DCHECK(browser_context);
-  if (browser_context->GetPermissionManager()) {
-    browser_context->GetPermissionManager()->UnsubscribePermissionStatusChange(
-        subscription->id);
-  }
-
-  PermissionStatusCallback callback = subscription->callback;
-
-  subscription->callback.Reset();
-  pending_subscriptions_.Remove(pending_subscription_id);
-
-  callback.Run(status);
-}
-
 }  // namespace content