Add mojom module suffix in .mojom files in content.

content/shell/browser/layout_test/layout_test_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 "content/shell/browser/layout_test/layout_test_permission_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/web_contents.h"
 #include "content/shell/browser/layout_test/layout_test_content_browser_client.h"
 #include "content/shell/browser/layout_test/layout_test_notification_manager.h"
 
 namespace content {
 
 struct LayoutTestPermissionManager::Subscription {
   PermissionDescription permission;
-  base::Callback<void(content::PermissionStatus)> callback;
-  PermissionStatus current_value;
+  base::Callback<void(content::mojom::PermissionStatus)> callback;
+  mojom::PermissionStatus current_value;
 };
 
 LayoutTestPermissionManager::PermissionDescription::PermissionDescription(
     PermissionType type,
     const GURL& origin,
     const GURL& embedding_origin)
     : type(type),
       origin(origin),
       embedding_origin(embedding_origin) {
 }
@@ skipping 25 matching lines @@
     : PermissionManager() {
 }
 
 LayoutTestPermissionManager::~LayoutTestPermissionManager() {
 }
 
 int LayoutTestPermissionManager::RequestPermission(
     PermissionType permission,
     RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const base::Callback<void(PermissionStatus)>& callback) {
+    const base::Callback<void(mojom::PermissionStatus)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   callback.Run(GetPermissionStatus(
       permission, requesting_origin,
       WebContents::FromRenderFrameHost(render_frame_host)
           ->GetLastCommittedURL().GetOrigin()));
   return kNoPendingOperation;
 }
 
 int LayoutTestPermissionManager::RequestPermissions(
     const std::vector<PermissionType>& permissions,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
-    const base::Callback<void(
-        const std::vector<PermissionStatus>&)>& callback) {
+    const base::Callback<void(const std::vector<mojom::PermissionStatus>&)>&
+        callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  std::vector<PermissionStatus> result(permissions.size());
+  std::vector<mojom::PermissionStatus> result(permissions.size());
   const GURL& embedding_origin =
       WebContents::FromRenderFrameHost(render_frame_host)
           ->GetLastCommittedURL().GetOrigin();
   for (const auto& permission : permissions) {
     result.push_back(GetPermissionStatus(
         permission, requesting_origin, embedding_origin));
   }
 
   callback.Run(result);
   return kNoPendingOperation;
@@ skipping 11 matching lines @@
 
   base::AutoLock lock(permissions_lock_);
 
   auto it = permissions_.find(
       PermissionDescription(permission, requesting_origin, embedding_origin));
   if (it == permissions_.end())
     return;
   permissions_.erase(it);
 }
 
-PermissionStatus LayoutTestPermissionManager::GetPermissionStatus(
+mojom::PermissionStatus LayoutTestPermissionManager::GetPermissionStatus(
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::AutoLock lock(permissions_lock_);
 
   auto it = permissions_.find(
       PermissionDescription(permission, requesting_origin, embedding_origin));
   if (it == permissions_.end())
-    return PermissionStatus::DENIED;
+    return mojom::PermissionStatus::DENIED;
   return it->second;
 }
 
 void LayoutTestPermissionManager::RegisterPermissionUsage(
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 int LayoutTestPermissionManager::SubscribePermissionStatusChange(
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
-    const base::Callback<void(PermissionStatus)>& callback) {
+    const base::Callback<void(mojom::PermissionStatus)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Subscription* subscription = new Subscription();
   subscription->permission =
       PermissionDescription(permission, requesting_origin, embedding_origin);
   subscription->callback = callback;
   subscription->current_value =
       GetPermissionStatus(permission,
                           subscription->permission.origin,
                           subscription->permission.embedding_origin);
 
   return subscriptions_.Add(subscription);
 }
 
 void LayoutTestPermissionManager::UnsubscribePermissionStatusChange(
     int subscription_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Whether |subscription_id| is known will be checked by the Remove() call.
   subscriptions_.Remove(subscription_id);
 }
 
 void LayoutTestPermissionManager::SetPermission(PermissionType permission,
-                                                PermissionStatus status,
+                                                mojom::PermissionStatus status,
                                                 const GURL& origin,
                                                 const GURL& embedding_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   PermissionDescription description(permission, origin, embedding_origin);
 
   base::AutoLock lock(permissions_lock_);
 
   auto it = permissions_.find(description);
   if (it == permissions_.end()) {
-    permissions_.insert(std::pair<PermissionDescription, PermissionStatus>(
-        description, status));
+    permissions_.insert(
+        std::pair<PermissionDescription, mojom::PermissionStatus>(description,
+                                                                  status));
   } else {
     it->second = status;
   }
 
   OnPermissionChanged(description, status);
 }
 
 void LayoutTestPermissionManager::ResetPermissions() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::AutoLock lock(permissions_lock_);
   permissions_.clear();
 }
 
 void LayoutTestPermissionManager::OnPermissionChanged(
     const PermissionDescription& permission,
-    PermissionStatus status) {
+    mojom::PermissionStatus status) {
   std::list<base::Closure> callbacks;
 
   for (SubscriptionsMap::iterator iter(&subscriptions_);
        !iter.IsAtEnd(); iter.Advance()) {
     Subscription* subscription = iter.GetCurrentValue();
     if (subscription->permission != permission)
       continue;
 
     if (subscription->current_value == status)
       continue;
 
     subscription->current_value = status;
 
     // Add the callback to |callbacks| which will be run after the loop to
     // prevent re-entrance issues.
     callbacks.push_back(base::Bind(subscription->callback, status));
   }
 
   for (const auto& callback : callbacks)
     callback.Run();
 }
 
 }  // namespace content