Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

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 <memory>
 #include <string>
+#include <utility>
 
 #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"
 
@@ skipping 228 matching lines @@
     bool user_gesture,
     const base::Callback<void(const std::vector<PermissionStatus>&)>&
         callback) {
   if (permissions.empty()) {
     callback.Run(std::vector<PermissionStatus>());
     return kNoPendingOperation;
   }
 
   const GURL& embedding_origin = LastCommittedOrigin(render_frame_host);
 
-  PendingRequest* pending_request =
-      new PendingRequest(permissions, requesting_origin, embedding_origin,
-                         GetRenderProcessID(render_frame_host),
-                         GetRenderFrameID(render_frame_host), callback);
+  auto pending_request = base::MakeUnique<PendingRequest>(
+      permissions, requesting_origin, embedding_origin,
+      GetRenderProcessID(render_frame_host),
+      GetRenderFrameID(render_frame_host), callback);
   std::vector<bool> should_delegate_requests =
       std::vector<bool>(permissions.size(), true);
   for (size_t i = 0; i < permissions.size(); ++i) {
     for (PendingRequestsMap::Iterator<PendingRequest> it(&pending_requests_);
          !it.IsAtEnd(); it.Advance()) {
       if (it.GetCurrentValue()->HasPermissionType(permissions[i]) &&
           it.GetCurrentValue()->requesting_origin == requesting_origin) {
         if (it.GetCurrentValue()->IsCompleted(permissions[i])) {
           pending_request->SetPermissionStatus(
               permissions[i],
               it.GetCurrentValue()->GetPermissionStatus(permissions[i]));
         }
         should_delegate_requests[i] = false;
         break;
       }
     }
   }
 
-  int request_id = pending_requests_.Add(pending_request);
+  // Keep copy of pointer for performing further operations after ownership is
+  // transferred to pending_requests_
+  PendingRequest* pending_request_raw = pending_request.get();
+  int request_id = pending_requests_.Add(std::move(pending_request));
 
-  AwBrowserPermissionRequestDelegate* delegate = GetDelegate(
-      pending_request->render_process_id, pending_request->render_frame_id);
+  AwBrowserPermissionRequestDelegate* delegate =
+      GetDelegate(pending_request_raw->render_process_id,
+                  pending_request_raw->render_frame_id);
 
   for (size_t i = 0; i < permissions.size(); ++i) {
     if (!should_delegate_requests[i])
       continue;
 
     if (!delegate) {
       DVLOG(0) << "Dropping permissions request for "
                << static_cast<int>(permissions[i]);
-      pending_request->SetPermissionStatus(permissions[i],
-                                           PermissionStatus::DENIED);
+      pending_request_raw->SetPermissionStatus(permissions[i],
+                                               PermissionStatus::DENIED);
       continue;
     }
 
     switch (permissions[i]) {
       case PermissionType::GEOLOCATION:
         delegate->RequestGeolocationPermission(
-            pending_request->requesting_origin,
+            pending_request_raw->requesting_origin,
             base::Bind(&OnRequestResponse, weak_ptr_factory_.GetWeakPtr(),
                        request_id, permissions[i]));
         break;
       case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
         delegate->RequestProtectedMediaIdentifierPermission(
-            pending_request->requesting_origin,
+            pending_request_raw->requesting_origin,
             base::Bind(&OnRequestResponse, weak_ptr_factory_.GetWeakPtr(),
                        request_id, permissions[i]));
         break;
       case PermissionType::MIDI_SYSEX:
         delegate->RequestMIDISysexPermission(
-            pending_request->requesting_origin,
+            pending_request_raw->requesting_origin,
             base::Bind(&OnRequestResponse, weak_ptr_factory_.GetWeakPtr(),
                        request_id, permissions[i]));
         break;
       case PermissionType::AUDIO_CAPTURE:
       case PermissionType::VIDEO_CAPTURE:
       case PermissionType::NOTIFICATIONS:
       case PermissionType::PUSH_MESSAGING:
       case PermissionType::DURABLE_STORAGE:
       case PermissionType::BACKGROUND_SYNC:
       case PermissionType::FLASH:
         NOTIMPLEMENTED() << "RequestPermissions is not implemented for "
                          << static_cast<int>(permissions[i]);
-        pending_request->SetPermissionStatus(permissions[i],
-                                             PermissionStatus::DENIED);
+        pending_request_raw->SetPermissionStatus(permissions[i],
+                                                 PermissionStatus::DENIED);
         break;
       case PermissionType::MIDI:
-        pending_request->SetPermissionStatus(permissions[i],
-                                             PermissionStatus::GRANTED);
+        pending_request_raw->SetPermissionStatus(permissions[i],
+                                                 PermissionStatus::GRANTED);
         break;
       case PermissionType::NUM:
         NOTREACHED() << "PermissionType::NUM was not expected here.";
-        pending_request->SetPermissionStatus(permissions[i],
-                                             PermissionStatus::DENIED);
+        pending_request_raw->SetPermissionStatus(permissions[i],
+                                                 PermissionStatus::DENIED);
         break;
     }
   }
 
   // If delegate resolve the permission synchronously, all requests could be
   // already resolved here.
   if (!pending_requests_.Lookup(request_id))
     return kNoPendingOperation;
 
   // If requests are resolved without calling delegate functions, e.g.
   // PermissionType::MIDI is permitted within the previous for-loop, all
   // requests could be already resolved, but still in the |pending_requests_|
   // without invoking the callback.
-  if (pending_request->IsCompleted()) {
-    std::vector<PermissionStatus> results = pending_request->results;
+  if (pending_request_raw->IsCompleted()) {
+    std::vector<PermissionStatus> results = pending_request_raw->results;
     pending_requests_.Remove(request_id);
     callback.Run(results);
     return kNoPendingOperation;
   }
 
   return request_id;
 }
 
 // static
 void AwPermissionManager::OnRequestResponse(
@@ skipping 183 matching lines @@
       ->GetLastCommittedURL().GetOrigin();
 }
 
 AwBrowserPermissionRequestDelegate* AwPermissionManager::GetDelegate(
     int render_process_id, int render_frame_id) {
   return AwBrowserPermissionRequestDelegate::FromID(render_process_id,
                                                     render_frame_id);
 }
 
 }  // namespace android_webview