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 226 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) {

[danakj, 2016/11/18 00:15:33]

same

[rlanday, 2016/11/18 23:46:56]

I am uncertain how to do this, as this method is mocked using gMock, which as
far as I can determine does not support mocking methods that take non-copyable
parameters (e.g. unique_ptr):
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/modules/presen...

[danakj, 2016/11/21 21:34:26]

Ah ok here's an example to work around gmock. Basically you don't mock the
method directly, you mock something close to it, and call that from an override
of the real method.

Here, SwapBuffers() takes a move-only object so we mock SwapBuffers_() instead
and call it from SwapBuffers()
https://cs.chromium.org/chromium/src/cc/output/gl_renderer_unittest.cc?rcl=0&...

   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));
     return;
   }
 
-  status->availability_callbacks.Add(callbacks);
+  status->availability_callbacks.Add(
+      std::unique_ptr<blink::WebPresentationAvailabilityCallbacks>(
+          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 "
                   << observer->url();
     return;
@@ skipping 269 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