Move geolocation and permission mojoms into components.

content/child/permissions/permission_dispatcher.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 "content/child/permissions/permission_dispatcher.h"
 
 #include "base/callback.h"
 #include "content/child/worker_task_runner.h"
 #include "content/public/common/service_registry.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/modules/permissions/WebPermissionObserver.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 using blink::WebPermissionObserver;
 
 namespace content {
 
 namespace {
 
-PermissionName GetPermissionName(blink::WebPermissionType type) {
+permission::Name GetPermissionName(blink::WebPermissionType type) {
   switch (type) {
     case blink::WebPermissionTypeGeolocation:
-      return PERMISSION_NAME_GEOLOCATION;
+      return permission::NAME_GEOLOCATION;
     case blink::WebPermissionTypeNotifications:
-      return PERMISSION_NAME_NOTIFICATIONS;
+      return permission::NAME_NOTIFICATIONS;
     case blink::WebPermissionTypePushNotifications:
-      return PERMISSION_NAME_PUSH_NOTIFICATIONS;
+      return permission::NAME_PUSH_NOTIFICATIONS;
     case blink::WebPermissionTypeMidiSysEx:
-      return PERMISSION_NAME_MIDI_SYSEX;
+      return permission::NAME_MIDI_SYSEX;
     case blink::WebPermissionTypeDurableStorage:
-        return PERMISSION_NAME_DURABLE_STORAGE;
+      return permission::NAME_DURABLE_STORAGE;
     case blink::WebPermissionTypeMidi:
-      return PERMISSION_NAME_MIDI;
+      return permission::NAME_MIDI;
     default:
       // The default statement is only there to prevent compilation failures if
       // WebPermissionType enum gets extended.
       NOTREACHED();
-      return PERMISSION_NAME_GEOLOCATION;
+      return permission::NAME_GEOLOCATION;
   }
 }
 
-PermissionStatus GetPermissionStatus(blink::WebPermissionStatus status) {
+permission::Status GetPermissionStatus(blink::WebPermissionStatus status) {
   switch (status) {
     case blink::WebPermissionStatusGranted:
-      return PERMISSION_STATUS_GRANTED;
+      return permission::STATUS_GRANTED;
     case blink::WebPermissionStatusDenied:
-      return PERMISSION_STATUS_DENIED;
+      return permission::STATUS_DENIED;
     case blink::WebPermissionStatusPrompt:
-      return PERMISSION_STATUS_ASK;
+      return permission::STATUS_ASK;
   }
 
   NOTREACHED();
-  return PERMISSION_STATUS_DENIED;
+  return permission::STATUS_DENIED;
 }
 
-blink::WebPermissionStatus GetWebPermissionStatus(PermissionStatus status) {
+blink::WebPermissionStatus GetWebPermissionStatus(permission::Status status) {
   switch (status) {
-    case PERMISSION_STATUS_GRANTED:
+    case permission::STATUS_GRANTED:
       return blink::WebPermissionStatusGranted;
-    case PERMISSION_STATUS_DENIED:
+    case permission::STATUS_DENIED:
       return blink::WebPermissionStatusDenied;
-    case PERMISSION_STATUS_ASK:
+    case permission::STATUS_ASK:
       return blink::WebPermissionStatusPrompt;
   }
 
   NOTREACHED();
   return blink::WebPermissionStatusDenied;
 }
 
 const int kNoWorkerThread = 0;
 
 }  // anonymous namespace
@@ skipping 47 matching lines @@
 
 void PermissionDispatcher::startListening(
     blink::WebPermissionType type,
     const blink::WebURL& origin,
     WebPermissionObserver* observer) {
   if (!IsObservable(type))
     return;
 
   RegisterObserver(observer);
 
-  GetNextPermissionChange(type,
-                          origin.string().utf8(),
-                          observer,
+  GetNextPermissionChange(type, origin.string().utf8(), observer,
                           // We initialize with an arbitrary value because the
                           // mojo service wants a value. Worst case, the
                           // observer will get notified about a non-change which
                           // should be a no-op. After the first notification,
                           // GetNextPermissionChange will be called with the
                           // latest known value.
-                          PERMISSION_STATUS_ASK);
+                          permission::STATUS_ASK);
 }
 
 void PermissionDispatcher::stopListening(WebPermissionObserver* observer) {
   UnregisterObserver(observer);
 }
 
 void PermissionDispatcher::QueryPermissionForWorker(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionCallback* callback,
@@ skipping 24 matching lines @@
     int worker_thread_id) {
   RevokePermissionInternal(type, origin, callback, worker_thread_id);
 }
 
 void PermissionDispatcher::StartListeningForWorker(
     blink::WebPermissionType type,
     const std::string& origin,
     int worker_thread_id,
     const base::Callback<void(blink::WebPermissionStatus)>& callback) {
   GetPermissionServicePtr()->GetNextPermissionChange(
-      GetPermissionName(type),
-      origin,
+      GetPermissionName(type), origin,
       // We initialize with an arbitrary value because the mojo service wants a
       // value. Worst case, the observer will get notified about a non-change
       // which should be a no-op. After the first notification,
       // GetNextPermissionChange will be called with the latest known value.
-      PERMISSION_STATUS_ASK,
+      permission::STATUS_ASK,
       base::Bind(&PermissionDispatcher::OnPermissionChangedForWorker,
-                 base::Unretained(this),
-                 worker_thread_id,
-                 callback));
+                 base::Unretained(this), worker_thread_id, callback));
 }
 
 void PermissionDispatcher::GetNextPermissionChangeForWorker(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionStatus status,
     int worker_thread_id,
     const base::Callback<void(blink::WebPermissionStatus)>& callback) {
   GetPermissionServicePtr()->GetNextPermissionChange(
       GetPermissionName(type),
@@ skipping 11 matching lines @@
     blink::WebPermissionStatus status) {
   callback->onSuccess(status);
 }
 
 void PermissionDispatcher::RunPermissionsCallbackOnWorkerThread(
     scoped_ptr<blink::WebPermissionsCallback> callback,
     scoped_ptr<blink::WebVector<blink::WebPermissionStatus>> statuses) {
   callback->onSuccess(blink::adoptWebPtr(statuses.release()));
 }
 
-PermissionServicePtr& PermissionDispatcher::GetPermissionServicePtr() {
+permission::PermissionServicePtr&
+PermissionDispatcher::GetPermissionServicePtr() {
   if (!permission_service_.get()) {
     service_registry_->ConnectToRemoteService(
         mojo::GetProxy(&permission_service_));
   }
   return permission_service_;
 }
 
 void PermissionDispatcher::QueryPermissionInternal(
     blink::WebPermissionType type,
     const std::string& origin,
@@ skipping 45 matching lines @@
     blink::WebPermissionsCallback* callback,
     int worker_thread_id) {
   // We need to save the |callback| in an ScopedVector so if |this| gets
   // deleted, the callback will not leak. In the case of |this| gets deleted,
   // the |permission_service_| pipe will be destroyed too so OnQueryPermission
   // will not be called.
   uintptr_t callback_key = reinterpret_cast<uintptr_t>(callback);
   permissions_callbacks_.add(callback_key,
       scoped_ptr<blink::WebPermissionsCallback>(callback));
 
-  mojo::Array<PermissionName> names(types.size());
+  mojo::Array<permission::Name> names(types.size());
   for (size_t i = 0; i < types.size(); ++i)
     names[i] = GetPermissionName(types[i]);
 
   GetPermissionServicePtr()->RequestPermissions(
       names.Pass(),
       origin,
       blink::WebUserGestureIndicator::isProcessingUserGesture(),
       base::Bind(&PermissionDispatcher::OnRequestPermissionsResponse,
                  base::Unretained(this),
                  worker_thread_id,
@@ skipping 15 matching lines @@
 
   GetPermissionServicePtr()->RevokePermission(
       GetPermissionName(type),
       origin,
       base::Bind(&PermissionDispatcher::OnPermissionResponse,
                  base::Unretained(this),
                  worker_thread_id,
                  callback_key));
 }
 
-void PermissionDispatcher::OnPermissionResponse(
-    int worker_thread_id,
-    uintptr_t callback_key,
-    PermissionStatus result) {
+void PermissionDispatcher::OnPermissionResponse(int worker_thread_id,
+                                                uintptr_t callback_key,
+                                                permission::Status result) {
   scoped_ptr<blink::WebPermissionCallback> callback =
       permission_callbacks_.take_and_erase(callback_key);
   blink::WebPermissionStatus status = GetWebPermissionStatus(result);
 
   if (worker_thread_id != kNoWorkerThread) {
     // If the worker is no longer running, ::PostTask() will return false and
     // gracefully fail, destroying the callback too.
     WorkerTaskRunner::Instance()->PostTask(
         worker_thread_id,
         base::Bind(&PermissionDispatcher::RunPermissionCallbackOnWorkerThread,
                    base::Passed(&callback), status));
     return;
   }
 
   callback->onSuccess(status);
 }
 
 void PermissionDispatcher::OnRequestPermissionsResponse(
     int worker_thread_id,
     uintptr_t callback_key,
-    const mojo::Array<PermissionStatus>& result) {
+    const mojo::Array<permission::Status>& result) {
   scoped_ptr<blink::WebPermissionsCallback> callback =
       permissions_callbacks_.take_and_erase(callback_key);
   scoped_ptr<blink::WebVector<blink::WebPermissionStatus>> statuses(
       new blink::WebVector<blink::WebPermissionStatus>(result.size()));
 
   for (size_t i = 0; i < result.size(); i++)
     statuses->operator[](i) = GetWebPermissionStatus(result[i]);
 
   if (worker_thread_id != kNoWorkerThread) {
     // If the worker is no longer running, ::PostTask() will return false and
     // gracefully fail, destroying the callback too.
     WorkerTaskRunner::Instance()->PostTask(
         worker_thread_id,
         base::Bind(&PermissionDispatcher::RunPermissionsCallbackOnWorkerThread,
                    base::Passed(&callback),
                    base::Passed(&statuses)));
     return;
   }
 
   callback->onSuccess(blink::adoptWebPtr(statuses.release()));
 }
 
-void PermissionDispatcher::OnPermissionChanged(
-    blink::WebPermissionType type,
-    const std::string& origin,
-    WebPermissionObserver* observer,
-    PermissionStatus status) {
+void PermissionDispatcher::OnPermissionChanged(blink::WebPermissionType type,
+                                               const std::string& origin,
+                                               WebPermissionObserver* observer,
+                                               permission::Status status) {
   if (!IsObserverRegistered(observer))
     return;
 
   observer->permissionChanged(type, GetWebPermissionStatus(status));
 
   GetNextPermissionChange(type, origin, observer, status);
 }
 
 void PermissionDispatcher::OnPermissionChangedForWorker(
     int worker_thread_id,
     const base::Callback<void(blink::WebPermissionStatus)>& callback,
-    PermissionStatus status) {
+    permission::Status status) {
   DCHECK(worker_thread_id != kNoWorkerThread);
 
   WorkerTaskRunner::Instance()->PostTask(
       worker_thread_id, base::Bind(callback, GetWebPermissionStatus(status)));
 }
 
 void PermissionDispatcher::GetNextPermissionChange(
     blink::WebPermissionType type,
     const std::string& origin,
     WebPermissionObserver* observer,
-    PermissionStatus current_status) {
+    permission::Status current_status) {
   GetPermissionServicePtr()->GetNextPermissionChange(
       GetPermissionName(type),
       origin,
       current_status,
       base::Bind(&PermissionDispatcher::OnPermissionChanged,
                  base::Unretained(this),
                  type,
                  origin,
                  base::Unretained(observer)));
 }
 
 }  // namespace content