Remove base::Tuple

media/gpu/android_video_encode_accelerator.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 "media/gpu/android_video_encode_accelerator.h"
 
 #include <memory>
 #include <set>
+#include <tuple>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
@@ skipping 221 matching lines @@
                             frame->stride(VideoFrame::kYPlane) &&
                         frame->row_bytes(VideoFrame::kUPlane) ==
                             frame->stride(VideoFrame::kUPlane) &&
                         frame->row_bytes(VideoFrame::kVPlane) ==
                             frame->stride(VideoFrame::kVPlane) &&
                         frame->coded_size() == frame->visible_rect().size(),
                     "Non-packed frame, or visible_rect != coded_size",
                     kInvalidArgumentError);
 
   pending_frames_.push(
-      base::MakeTuple(frame, force_keyframe, base::Time::Now()));
+      std::make_tuple(frame, force_keyframe, base::Time::Now()));
   DoIOTask();
 }
 
 void AndroidVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOG(3) << __PRETTY_FUNCTION__ << ": bitstream_buffer_id=" << buffer.id();
   DCHECK(thread_checker_.CalledOnValidThread());
   available_bitstream_buffers_.push_back(buffer);
   DoIOTask();
 }
@@ skipping 42 matching lines @@
       media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
   if (status != media::MEDIA_CODEC_OK) {
     DCHECK(status == media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER ||
            status == media::MEDIA_CODEC_ERROR);
     RETURN_ON_FAILURE(status != media::MEDIA_CODEC_ERROR, "MediaCodec error",
                       kPlatformFailureError);
     return;
   }
 
   const PendingFrames::value_type& input = pending_frames_.front();
-  bool is_key_frame = base::get<1>(input);
+  bool is_key_frame = std::get<1>(input);
   if (is_key_frame) {
     // Ideally MediaCodec would honor BUFFER_FLAG_SYNC_FRAME so we could
     // indicate this in the QueueInputBuffer() call below and guarantee _this_
     // frame be encoded as a key frame, but sadly that flag is ignored.
     // Instead, we request a key frame "soon".
     media_codec_->RequestKeyFrameSoon();
   }
-  scoped_refptr<VideoFrame> frame = base::get<0>(input);
+  scoped_refptr<VideoFrame> frame = std::get<0>(input);
 
   uint8_t* buffer = NULL;
   size_t capacity = 0;
   status = media_codec_->GetInputBuffer(input_buf_index, &buffer, &capacity);
   RETURN_ON_FAILURE(status == media::MEDIA_CODEC_OK, "GetInputBuffer failed.",
                     kPlatformFailureError);
 
   size_t queued_size =
       VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420, frame->coded_size());
   RETURN_ON_FAILURE(capacity >= queued_size,
@@ skipping 13 matching lines @@
       frame->data(VideoFrame::kUPlane), frame->stride(VideoFrame::kUPlane),
       frame->data(VideoFrame::kVPlane), frame->stride(VideoFrame::kVPlane),
       dst_y, dst_stride_y, dst_uv, dst_stride_uv, frame->coded_size().width(),
       frame->coded_size().height());
   RETURN_ON_FAILURE(converted, "Failed to I420ToNV12!", kPlatformFailureError);
 
   fake_input_timestamp_ += base::TimeDelta::FromMicroseconds(1);
   status = media_codec_->QueueInputBuffer(input_buf_index, NULL, queued_size,
                                           fake_input_timestamp_);
   UMA_HISTOGRAM_TIMES("Media.AVDA.InputQueueTime",
-                      base::Time::Now() - base::get<2>(input));
+                      base::Time::Now() - std::get<2>(input));
   RETURN_ON_FAILURE(status == media::MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status,
                     kPlatformFailureError);
   ++num_buffers_at_codec_;
   pending_frames_.pop();
 }
 
 void AndroidVideoEncodeAccelerator::DequeueOutput() {
   if (!client_ptr_factory_->GetWeakPtr() ||
       available_bitstream_buffers_.empty() || num_buffers_at_codec_ == 0) {
@@ skipping 51 matching lines @@
   --num_buffers_at_codec_;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
                  client_ptr_factory_->GetWeakPtr(), bitstream_buffer.id(), size,
                  key_frame, base::Time::Now() - base::Time()));
 }
 
 }  // namespace media