Refactoring: CastTransport InitializeAudio/InitializeVideo.

chrome/renderer/media/cast_session_delegate.cc

 // Copyright 2013 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 "chrome/renderer/media/cast_session_delegate.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/callback_helpers.h"
@@ skipping 73 matching lines @@
                  base::Unretained(cast_environment_->logger()))));
 }
 
 void CastSessionDelegateBase::StatusNotificationCB(
     const ErrorCallback& error_callback,
     media::cast::CastTransportStatus status) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   std::string error_message;
 
   switch (status) {
-    case media::cast::TRANSPORT_AUDIO_UNINITIALIZED:
-    case media::cast::TRANSPORT_VIDEO_UNINITIALIZED:
-    case media::cast::TRANSPORT_AUDIO_INITIALIZED:
-    case media::cast::TRANSPORT_VIDEO_INITIALIZED:
+    case media::cast::TRANSPORT_STREAM_UNINITIALIZED:
+    case media::cast::TRANSPORT_STREAM_INITIALIZED:
       return; // Not errors, do nothing.
     case media::cast::TRANSPORT_INVALID_CRYPTO_CONFIG:
       error_callback.Run("Invalid encrypt/decrypt configuration.");
       break;
     case media::cast::TRANSPORT_SOCKET_ERROR:
       error_callback.Run("Socket error.");
       break;
   }
 }
 
@@ skipping 73 matching lines @@
     event_subscribers_->RemoveEventSubscribers(is_audio);
 }
 
 void CastSessionDelegate::GetEventLogsAndReset(
     bool is_audio,
     const std::string& extra_data,
     const EventLogsCallback& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!event_subscribers_.get()) {
-    callback.Run(base::WrapUnique(new base::BinaryValue));
+    callback.Run(base::MakeUnique<base::BinaryValue>());
     return;
   }
 
   media::cast::EncodingEventSubscriber* subscriber =
       event_subscribers_->GetEncodingEventSubscriber(is_audio);
   if (!subscriber) {
-    callback.Run(base::WrapUnique(new base::BinaryValue));
+    callback.Run(base::MakeUnique<base::BinaryValue>());
     return;
   }
 
   media::cast::proto::LogMetadata metadata;
   media::cast::FrameEventList frame_events;
   media::cast::PacketEventList packet_events;
 
   subscriber->GetEventsAndReset(&metadata, &frame_events, &packet_events);
 
   if (!extra_data.empty())
@@ skipping 10 matching lines @@
   bool success = media::cast::SerializeEvents(metadata,
                                               frame_events,
                                               packet_events,
                                               true,
                                               media::cast::kMaxSerializedBytes,
                                               serialized_log.get(),
                                               &output_bytes);
 
   if (!success) {
     DVLOG(2) << "Failed to serialize event log.";
-    callback.Run(base::WrapUnique(new base::BinaryValue));
+    callback.Run(base::MakeUnique<base::BinaryValue>());
     return;
   }
 
   DVLOG(2) << "Serialized log length: " << output_bytes;
 
   std::unique_ptr<base::BinaryValue> blob(
       new base::BinaryValue(std::move(serialized_log), output_bytes));
   callback.Run(std::move(blob));
 }
 
 void CastSessionDelegate::GetStatsAndReset(bool is_audio,
                                            const StatsCallback& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   if (!event_subscribers_.get()) {
-    callback.Run(base::WrapUnique(new base::DictionaryValue));
+    callback.Run(base::MakeUnique<base::DictionaryValue>());
     return;
   }
 
   media::cast::StatsEventSubscriber* subscriber =
       event_subscribers_->GetStatsEventSubscriber(is_audio);
   if (!subscriber) {
-    callback.Run(base::WrapUnique(new base::DictionaryValue));
+    callback.Run(base::MakeUnique<base::DictionaryValue>());
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> stats = subscriber->GetStats();
   subscriber->Reset();
 
   callback.Run(std::move(stats));
 }
 
 void CastSessionDelegate::OnOperationalStatusChange(
@@ skipping 42 matching lines @@
       error_callback.Run(base::StringPrintf("%s codec runtime error.",
                                             is_for_audio ? "Audio" : "Video"));
       break;
   }
 }
 
 void CastSessionDelegate::ReceivePacket(
     std::unique_ptr<media::cast::Packet> packet) {
   // Do nothing (frees packet)
 }