Move geolocation and permission mojoms into WebKit/public/platform.

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 content::mojom::PermissionStatus;
+using blink::mojom::PermissionStatus;
 using content::PermissionType;
 
 namespace android_webview {
 
 class LastRequestResultCache {
  public:
   LastRequestResultCache() = default;
 
   void SetResult(PermissionType permission,
                  const GURL& requesting_origin,
                  const GURL& embedding_origin,
                  PermissionStatus status) {
-    DCHECK(status == content::mojom::PermissionStatus::GRANTED ||
-           status == content::mojom::PermissionStatus::DENIED);
+    DCHECK(status == PermissionStatus::GRANTED ||
+           status == PermissionStatus::DENIED);
 
     // TODO(ddorwin): We should be denying empty origins at a higher level.
     if (requesting_origin.is_empty() || embedding_origin.is_empty()) {
       DLOG(WARNING) << "Not caching result because of empty origin.";
       return;
     }
 
     if (!requesting_origin.is_valid()) {
       NOTREACHED() << requesting_origin.possibly_invalid_spec();
       return;
@@ skipping 16 matching lines @@
       return;
     }
     pmi_result_cache_[key] = status;
   }
 
   PermissionStatus GetResult(PermissionType permission,
                              const GURL& requesting_origin,
                              const GURL& embedding_origin) const {
     // TODO(ddorwin): We should be denying empty origins at a higher level.
     if (requesting_origin.is_empty() || embedding_origin.is_empty()) {
-      return content::mojom::PermissionStatus::ASK;
+      return PermissionStatus::ASK;
     }
 
     DCHECK(requesting_origin.is_valid())
         << requesting_origin.possibly_invalid_spec();
     DCHECK(embedding_origin.is_valid())
         << embedding_origin.possibly_invalid_spec();
 
     if (permission != PermissionType::PROTECTED_MEDIA_IDENTIFIER) {
       NOTREACHED() << "Results are only cached for PROTECTED_MEDIA_IDENTIFIER";
-      return content::mojom::PermissionStatus::ASK;
+      return PermissionStatus::ASK;
     }
 
     std::string key = GetCacheKey(requesting_origin, embedding_origin);
     StatusMap::const_iterator it = pmi_result_cache_.find(key);
     if (it == pmi_result_cache_.end()) {
       DLOG(WARNING) << "GetResult() called for uncached origins: " << key;
-      return content::mojom::PermissionStatus::ASK;
+      return PermissionStatus::ASK;
     }
 
     DCHECK(!key.empty());
     return it->second;
   }
 
   void ClearResult(PermissionType permission,
                    const GURL& requesting_origin,
                    const GURL& embedding_origin) {
     // TODO(ddorwin): We should be denying empty origins at a higher level.
@@ skipping 74 matching lines @@
     const GURL& requesting_origin,
     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::mojom::PermissionStatus::DENIED);
+    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;
@@ skipping 46 matching lines @@
       }
       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(content::mojom::PermissionStatus::DENIED);
+      callback.Run(PermissionStatus::DENIED);
       break;
     case PermissionType::MIDI:
-      callback.Run(content::mojom::PermissionStatus::GRANTED);
+      callback.Run(PermissionStatus::GRANTED);
       break;
     case PermissionType::NUM:
       NOTREACHED() << "PermissionType::NUM was not expected here.";
-      callback.Run(content::mojom::PermissionStatus::DENIED);
+      callback.Run(PermissionStatus::DENIED);
       break;
   }
   return request_id;
 }
 
 int AwPermissionManager::RequestPermissions(
     const std::vector<PermissionType>& permissions,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     const base::Callback<void(
@@ skipping 13 matching lines @@
   callback.Run(result);
   return kNoPendingOperation;
 }
 
 // static
 void AwPermissionManager::OnRequestResponse(
     const base::WeakPtr<AwPermissionManager>& manager,
     int request_id,
     const base::Callback<void(PermissionStatus)>& callback,
     bool allowed) {
-  PermissionStatus status = allowed ? content::mojom::PermissionStatus::GRANTED
-                                    : content::mojom::PermissionStatus::DENIED;
+  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);
@@ skipping 83 matching lines @@
 
 PermissionStatus AwPermissionManager::GetPermissionStatus(
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   // Method is called outside the Permissions API only for this permission.
   if (permission == PermissionType::PROTECTED_MEDIA_IDENTIFIER) {
     return result_cache_->GetResult(permission, requesting_origin,
                                     embedding_origin);
   } else if (permission == PermissionType::MIDI) {
-    return content::mojom::PermissionStatus::GRANTED;
+    return PermissionStatus::GRANTED;
   }
 
-  return content::mojom::PermissionStatus::DENIED;
+  return PermissionStatus::DENIED;
 }
 
 void AwPermissionManager::RegisterPermissionUsage(
     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 kNoPendingOperation;
 }
 
 void AwPermissionManager::UnsubscribePermissionStatusChange(
     int subscription_id) {
 }
 
 }  // namespace android_webview