Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/renderer/presentation/presentation_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/renderer/presentation/presentation_dispatcher.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 85 matching lines @@
   // There shouldn't be any swapping from one non-null controller to another.
   DCHECK(controller != controller_ && (!controller || !controller_));
   controller_ = controller;
   // The controller is set to null when the frame is about to be detached.
   // Nothing is listening for screen availability anymore but the Mojo service
   // will know about the frame being detached anyway.
 }
 
 void PresentationDispatcher::startSession(
     const blink::WebVector<blink::WebURL>& presentationUrls,
-    blink::WebPresentationConnectionClientCallbacks* callback) {
+    std::unique_ptr<blink::WebPresentationConnectionClientCallbacks> callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
   std::vector<GURL> urls;
   for (const auto& url : presentationUrls)
     urls.push_back(url);
 
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
   // to be destroyed so we transfer its ownership to the mojo callback.
   presentation_service_->StartSession(
       urls, base::Bind(&PresentationDispatcher::OnSessionCreated,
-                       base::Unretained(this), base::Owned(callback)));
+                       base::Unretained(this), base::Passed(&callback)));
 }
 
 void PresentationDispatcher::joinSession(
     const blink::WebVector<blink::WebURL>& presentationUrls,
     const blink::WebString& presentationId,
-    blink::WebPresentationConnectionClientCallbacks* callback) {
+    std::unique_ptr<blink::WebPresentationConnectionClientCallbacks> callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
   std::vector<GURL> urls;
   for (const auto& url : presentationUrls)
     urls.push_back(url);
 
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
   // to be destroyed so we transfer its ownership to the mojo callback.
   presentation_service_->JoinSession(
       urls, presentationId.utf8(),
       base::Bind(&PresentationDispatcher::OnSessionCreated,
-                 base::Unretained(this), base::Owned(callback)));
+                 base::Unretained(this), base::Passed(&callback)));
 }
 
 void PresentationDispatcher::sendString(const blink::WebURL& presentationUrl,
                                         const blink::WebString& presentationId,
                                         const blink::WebString& message) {
   if (message.utf8().size() > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
     // into smaller chunks later.
     LOG(WARNING) << "message size exceeded limit!";
@@ skipping 87 matching lines @@
 
 void PresentationDispatcher::terminateSession(
     const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
   presentation_service_->Terminate(presentationUrl, presentationId.utf8());
 }
 
 void PresentationDispatcher::getAvailability(
     const blink::WebURL& availabilityUrl,
-    blink::WebPresentationAvailabilityCallbacks* callbacks) {
+    std::unique_ptr<blink::WebPresentationAvailabilityCallbacks> callbacks) {
   AvailabilityStatus* status = nullptr;
   auto status_it = availability_status_.find(availabilityUrl);
   if (status_it == availability_status_.end()) {
     status = new AvailabilityStatus(availabilityUrl);
     availability_status_[availabilityUrl] = base::WrapUnique(status);
   } else {
     status = status_it->second.get();
   }
   DCHECK(status);
 
   if (status->listening_state == ListeningState::ACTIVE) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&blink::WebPresentationAvailabilityCallbacks::onSuccess,
-                   base::Owned(callbacks),
-                   status->last_known_availability));
+                   base::Passed(&callbacks), status->last_known_availability));
     return;
   }
 
-  status->availability_callbacks.Add(callbacks);
+  status->availability_callbacks.Add(std::move(callbacks));
   UpdateListeningState(status);
 }
 
 void PresentationDispatcher::startListening(
     blink::WebPresentationAvailabilityObserver* observer) {
   auto status_it = availability_status_.find(observer->url());
   if (status_it == availability_status_.end()) {
     DLOG(WARNING) << "Start listening for availability for unknown URL "
                   << GURL(observer->url());
     return;
@@ skipping 99 matching lines @@
     return;
 
   if (!session_info.is_null()) {
     presentation_service_->ListenForSessionMessages(session_info.Clone());
     controller_->didStartDefaultSession(
         new PresentationConnectionClient(std::move(session_info)));
   }
 }
 
 void PresentationDispatcher::OnSessionCreated(
-    blink::WebPresentationConnectionClientCallbacks* callback,
+    std::unique_ptr<blink::WebPresentationConnectionClientCallbacks> callback,
     blink::mojom::PresentationSessionInfoPtr session_info,
     blink::mojom::PresentationErrorPtr error) {
   DCHECK(callback);
   if (!error.is_null()) {
     DCHECK(session_info.is_null());
     callback->onError(blink::WebPresentationError(
         GetWebPresentationErrorTypeFromMojo(error->error_type),
         blink::WebString::fromUTF8(error->message)));
     return;
   }
@@ skipping 149 matching lines @@
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
     const GURL& availability_url)
     : url(availability_url),
       last_known_availability(false),
       listening_state(ListeningState::INACTIVE) {}
 
 PresentationDispatcher::AvailabilityStatus::~AvailabilityStatus() {
 }
 
 }  // namespace content