CallbackPromiseAdapter types should be more compatible with WebCallbacks (2/3).

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 <algorithm>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 207 matching lines @@
 
   presentation_service_->CloseSession(
       presentationUrl.utf8(),
       presentationId.utf8());
 }
 
 void PresentationDispatcher::getAvailability(
     const blink::WebString& presentationUrl,
     blink::WebPresentationAvailabilityCallbacks* callbacks) {
   if (listening_state_ == ListeningState::Active) {
-    callbacks->onSuccess(new bool(last_known_availability_));
+    callbacks->onSuccess(last_known_availability_);
     delete callbacks;
     return;
   }
 
   availability_callbacks_.Add(callbacks);
   UpdateListeningState();
 }
 
 void PresentationDispatcher::startListening(
     blink::WebPresentationAvailabilityObserver* observer) {
@@ skipping 31 matching lines @@
   last_known_availability_ = available;
 
   if (listening_state_ == ListeningState::Waiting)
     listening_state_ = ListeningState::Active;
 
   for (auto observer : availability_observers_)
     observer->availabilityChanged(available);
 
   for (AvailabilityCallbacksMap::iterator iter(&availability_callbacks_);
        !iter.IsAtEnd(); iter.Advance()) {
-    iter.GetCurrentValue()->onSuccess(new bool(available));
+    iter.GetCurrentValue()->onSuccess(available);
   }
   availability_callbacks_.Clear();
 
   UpdateListeningState();
 }
 
 void PresentationDispatcher::OnScreenAvailabilityNotSupported() {
   DCHECK(listening_state_ == ListeningState::Waiting);
 
   for (AvailabilityCallbacksMap::iterator iter(&availability_callbacks_);
        !iter.IsAtEnd(); iter.Advance()) {
-    iter.GetCurrentValue()->onError(new blink::WebPresentationError(
+    iter.GetCurrentValue()->onError(blink::WebPresentationError(
         blink::WebPresentationError::ErrorTypeAvailabilityNotSupported,
         blink::WebString::fromUTF8(
             "getAvailability() isn't supported at the moment. It can be due to"
             "a permanent or temporary system limitation. It is recommended to"
             "try to blindly start a session in that case.")));
   }
   availability_callbacks_.Clear();
 
   UpdateListeningState();
 }
@@ skipping 15 matching lines @@
   }
 }
 
 void PresentationDispatcher::OnSessionCreated(
     blink::WebPresentationSessionClientCallbacks* callback,
     presentation::PresentationSessionInfoPtr session_info,
     presentation::PresentationErrorPtr error) {
   DCHECK(callback);
   if (!error.is_null()) {
     DCHECK(session_info.is_null());
-    callback->onError(new blink::WebPresentationError(
+    callback->onError(blink::WebPresentationError(
         GetWebPresentationErrorTypeFromMojo(error->error_type),
         blink::WebString::fromUTF8(error->message)));
     return;
   }
 
   DCHECK(!session_info.is_null());
-  callback->onSuccess(new PresentationSessionClient(session_info.Clone()));
+  callback->onSuccess(
+      blink::adoptWebPtr(new PresentationSessionClient(session_info.Clone())));
   presentation_service_->ListenForSessionMessages(session_info.Pass());
 }
 
 void PresentationDispatcher::OnSessionStateChanged(
     presentation::PresentationSessionInfoPtr session_info,
     presentation::PresentationSessionState session_state) {
   if (!controller_)
     return;
 
   DCHECK(!session_info.is_null());
@@ skipping 113 matching lines @@
 
   presentation::SessionMessagePtr session_message =
       presentation::SessionMessage::New();
   session_message->type = type;
   std::vector<uint8> tmp_data_vector(data, data + length);
   session_message->data.Swap(&tmp_data_vector);
   return new SendMessageRequest(session_info.Pass(), session_message.Pass());
 }
 
 }  // namespace content