media: Drop "media::" in media/gpu

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 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_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 27 matching lines @@
 #include "media/gpu/shared_memory_region.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 #include "media/mojo/services/mojo_cdm_service.h"
 #endif
 
-#define POST_ERROR(error_code, error_message)                        \
-  do {                                                               \
-    DLOG(ERROR) << error_message;                                    \
-    PostError(FROM_HERE, media::VideoDecodeAccelerator::error_code); \
+#define POST_ERROR(error_code, error_message)                 \
+  do {                                                        \
+    DLOG(ERROR) << error_message;                             \
+    PostError(FROM_HERE, VideoDecodeAccelerator::error_code); \
   } while (0)
 
 namespace media {
 
-enum { kNumPictureBuffers = media::limits::kMaxVideoFrames + 1 };
+enum { kNumPictureBuffers = limits::kMaxVideoFrames + 1 };
 
 // Max number of bitstreams notified to the client with
 // NotifyEndOfBitstreamBuffer() before getting output from the bitstream.
 enum { kMaxBitstreamsNotifiedInAdvance = 32 };
 
 // MediaCodec is only guaranteed to support baseline, but some devices may
 // support others. Advertise support for all H264 profiles and let the
 // MediaCodec fail when decoding if it's not actually supported. It's assumed
 // that consumers won't have software fallback for H264 on Android anyway.
-static const media::VideoCodecProfile kSupportedH264Profiles[] = {
-    media::H264PROFILE_BASELINE,
-    media::H264PROFILE_MAIN,
-    media::H264PROFILE_EXTENDED,
-    media::H264PROFILE_HIGH,
-    media::H264PROFILE_HIGH10PROFILE,
-    media::H264PROFILE_HIGH422PROFILE,
-    media::H264PROFILE_HIGH444PREDICTIVEPROFILE,
-    media::H264PROFILE_SCALABLEBASELINE,
-    media::H264PROFILE_SCALABLEHIGH,
-    media::H264PROFILE_STEREOHIGH,
-    media::H264PROFILE_MULTIVIEWHIGH};
+static const VideoCodecProfile kSupportedH264Profiles[] = {
+    H264PROFILE_BASELINE,
+    H264PROFILE_MAIN,
+    H264PROFILE_EXTENDED,
+    H264PROFILE_HIGH,
+    H264PROFILE_HIGH10PROFILE,
+    H264PROFILE_HIGH422PROFILE,
+    H264PROFILE_HIGH444PREDICTIVEPROFILE,
+    H264PROFILE_SCALABLEBASELINE,
+    H264PROFILE_SCALABLEHIGH,
+    H264PROFILE_STEREOHIGH,
+    H264PROFILE_MULTIVIEWHIGH};
 
 // Because MediaCodec is thread-hostile (must be poked on a single thread) and
 // has no callback mechanism (b/11990118), we must drive it by polling for
 // complete frames (and available input buffers, when the codec is fully
 // saturated).  This function defines the polling delay.  The value used is an
 // arbitrary choice that trades off CPU utilization (spinning) against latency.
 // Mirrors android_video_encode_accelerator.cc:EncodePollDelay().
 static inline const base::TimeDelta DecodePollDelay() {
   // An alternative to this polling scheme could be to dedicate a new thread
   // (instead of using the ChildThread) to run the MediaCodec, and make that
@@ skipping 274 matching lines @@
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
 AndroidVideoDecodeAccelerator::CodecConfig::CodecConfig() {}
 
 AndroidVideoDecodeAccelerator::CodecConfig::~CodecConfig() {}
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
-    const media::BitstreamBuffer& bitstream_buffer)
+    const BitstreamBuffer& bitstream_buffer)
     : buffer(bitstream_buffer) {
   if (buffer.id() != -1)
     memory.reset(new SharedMemoryRegion(buffer, true));
 }
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
     BitstreamRecord&& other)
     : buffer(std::move(other.buffer)), memory(std::move(other.memory)) {}
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::~BitstreamRecord() {}
@@ skipping 57 matching lines @@
 
   // We signalled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
 
   if (config_.is_encrypted && !deferred_initialization_pending_) {
     DLOG(ERROR) << "Deferred initialization must be used for encrypted streams";
     return false;
   }
 
-  if (codec_config_->codec_ != media::kCodecVP8 &&
-      codec_config_->codec_ != media::kCodecVP9 &&
-      codec_config_->codec_ != media::kCodecH264) {
+  if (codec_config_->codec_ != kCodecVP8 &&
+      codec_config_->codec_ != kCodecVP9 &&
+      codec_config_->codec_ != kCodecH264) {
     LOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // or if the stream is encrypted.
-  if ((codec_config_->codec_ == media::kCodecVP8 ||
-       codec_config_->codec_ == media::kCodecVP9) &&
+  if ((codec_config_->codec_ == kCodecVP8 ||
+       codec_config_->codec_ == kCodecVP9) &&
       !config_.is_encrypted &&
-      media::VideoCodecBridge::IsKnownUnaccelerated(
-          codec_config_->codec_, media::MEDIA_CODEC_DECODER)) {
+      VideoCodecBridge::IsKnownUnaccelerated(codec_config_->codec_,
+                                             MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
-             << (codec_config_->codec_ == media::kCodecVP8 ? "vp8" : "vp9")
+             << (codec_config_->codec_ == kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
     return false;
   }
 
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
     LOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
@@ skipping 116 matching lines @@
     return false;
   if (pending_bitstream_records_.empty())
     return false;
 
   int input_buf_index = pending_input_buf_index_;
 
   // Do not dequeue a new input buffer if we failed with MEDIA_CODEC_NO_KEY.
   // That status does not return this buffer back to the pool of
   // available input buffers. We have to reuse it in QueueSecureInputBuffer().
   if (input_buf_index == -1) {
-    media::MediaCodecStatus status =
+    MediaCodecStatus status =
         media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
     switch (status) {
-      case media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
+      case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER:
         return false;
-      case media::MEDIA_CODEC_ERROR:
+      case MEDIA_CODEC_ERROR:
         POST_ERROR(PLATFORM_FAILURE, "Failed to DequeueInputBuffer");
         return false;
-      case media::MEDIA_CODEC_OK:
+      case MEDIA_CODEC_OK:
         break;
       default:
         NOTREACHED() << "Unknown DequeueInputBuffer status " << status;
         return false;
     }
   }
 
   DCHECK_NE(input_buf_index, -1);
 
-  media::BitstreamBuffer bitstream_buffer =
-      pending_bitstream_records_.front().buffer;
+  BitstreamBuffer bitstream_buffer = pending_bitstream_records_.front().buffer;
 
   if (bitstream_buffer.id() == -1) {
     pending_bitstream_records_.pop();
     TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
                    pending_bitstream_records_.size());
 
     media_codec_->QueueEOS(input_buf_index);
     return true;
   }
 
   std::unique_ptr<SharedMemoryRegion> shm;
 
   if (pending_input_buf_index_ == -1) {
     // When |pending_input_buf_index_| is not -1, the buffer is already dequeued
     // from MediaCodec, filled with data and bitstream_buffer.handle() is
     // closed.
     shm = std::move(pending_bitstream_records_.front().memory);
 
     if (!shm->Map()) {
       POST_ERROR(UNREADABLE_INPUT, "Failed to SharedMemoryRegion::Map()");
       return false;
     }
   }
 
   const base::TimeDelta presentation_timestamp =
       bitstream_buffer.presentation_timestamp();
-  DCHECK(presentation_timestamp != media::kNoTimestamp())
+  DCHECK(presentation_timestamp != kNoTimestamp())
       << "Bitstream buffers must have valid presentation timestamps";
 
   // There may already be a bitstream buffer with this timestamp, e.g., VP9 alt
   // ref frames, but it's OK to overwrite it because we only expect a single
   // output frame to have that timestamp. AVDA clients only use the bitstream
   // buffer id in the returned Pictures to map a bitstream buffer back to a
   // timestamp on their side, so either one of the bitstream buffer ids will
   // result in them finding the right timestamp.
   bitstream_buffers_in_decoder_[presentation_timestamp] = bitstream_buffer.id();
 
   // Notice that |memory| will be null if we repeatedly enqueue the same buffer,
   // this happens after MEDIA_CODEC_NO_KEY.
   const uint8_t* memory =
       shm ? static_cast<const uint8_t*>(shm->memory()) : nullptr;
   const std::string& key_id = bitstream_buffer.key_id();
   const std::string& iv = bitstream_buffer.iv();
-  const std::vector<media::SubsampleEntry>& subsamples =
-      bitstream_buffer.subsamples();
+  const std::vector<SubsampleEntry>& subsamples = bitstream_buffer.subsamples();
 
-  media::MediaCodecStatus status;
+  MediaCodecStatus status;
   if (key_id.empty() || iv.empty()) {
     status = media_codec_->QueueInputBuffer(input_buf_index, memory,
                                             bitstream_buffer.size(),
                                             presentation_timestamp);
   } else {
     status = media_codec_->QueueSecureInputBuffer(
         input_buf_index, memory, bitstream_buffer.size(), key_id, iv,
         subsamples, presentation_timestamp);
   }
 
   DVLOG(2) << __FUNCTION__
            << ": Queue(Secure)InputBuffer: pts:" << presentation_timestamp
            << " status:" << status;
 
-  if (status == media::MEDIA_CODEC_NO_KEY) {
+  if (status == MEDIA_CODEC_NO_KEY) {
     // Keep trying to enqueue the same input buffer.
     // The buffer is owned by us (not the MediaCodec) and is filled with data.
     DVLOG(1) << "QueueSecureInputBuffer failed: NO_KEY";
     pending_input_buf_index_ = input_buf_index;
     state_ = WAITING_FOR_KEY;
     return false;
   }
 
   pending_input_buf_index_ = -1;
   pending_bitstream_records_.pop();
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
                  pending_bitstream_records_.size());
   // We should call NotifyEndOfBitstreamBuffer(), when no more decoded output
   // will be returned from the bitstream buffer. However, MediaCodec API is
   // not enough to guarantee it.
   // So, here, we calls NotifyEndOfBitstreamBuffer() in advance in order to
   // keep getting more bitstreams from the client, and throttle them by using
   // |bitstreams_notified_in_advance_|.
   // TODO(dwkang): check if there is a way to remove this workaround.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                  weak_this_factory_.GetWeakPtr(), bitstream_buffer.id()));
   bitstreams_notified_in_advance_.push_back(bitstream_buffer.id());
 
-  if (status != media::MEDIA_CODEC_OK) {
+  if (status != MEDIA_CODEC_OK) {
     POST_ERROR(PLATFORM_FAILURE, "Failed to QueueInputBuffer: " << status);
     return false;
   }
 
   return true;
 }
 
 bool AndroidVideoDecodeAccelerator::DequeueOutput() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DequeueOutput");
   base::AutoReset<bool> auto_reset(&defer_errors_, true);
   if (state_ == ERROR || state_ == WAITING_FOR_CODEC)
     return false;
   if (picturebuffers_requested_ && output_picture_buffers_.empty())
     return false;
   if (!output_picture_buffers_.empty() && free_picture_ids_.empty()) {
     // Don't have any picture buffer to send. Need to wait.
     return false;
   }
 
   bool eos = false;
   base::TimeDelta presentation_timestamp;
   int32_t buf_index = 0;
   do {
     size_t offset = 0;
     size_t size = 0;
 
     TRACE_EVENT_BEGIN0("media", "AVDA::DequeueOutput");
-    media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
+    MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut(), &buf_index, &offset, &size, &presentation_timestamp,
         &eos, NULL);
     TRACE_EVENT_END2("media", "AVDA::DequeueOutput", "status", status,
                      "presentation_timestamp (ms)",
                      presentation_timestamp.InMilliseconds());
 
     switch (status) {
-      case media::MEDIA_CODEC_ERROR:
+      case MEDIA_CODEC_ERROR:
         // Do not post an error if we are draining for reset and destroy.
         // Instead, run the drain completion task.
         if (IsDrainingForResetOrDestroy()) {
           DVLOG(1) << __FUNCTION__ << ": error while codec draining";
           state_ = ERROR;
           OnDrainCompleted();
         } else {
           POST_ERROR(PLATFORM_FAILURE, "DequeueOutputBuffer failed.");
         }
         return false;
 
-      case media::MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
+      case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
         return false;
 
-      case media::MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: {
+      case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: {
         // An OUTPUT_FORMAT_CHANGED is not reported after flush() if the frame
         // size does not change. Therefore we have to keep track on the format
         // even if draining, unless we are draining for destroy.
         if (drain_type_ == DRAIN_FOR_DESTROY)
           return true;  // ignore
 
-        if (media_codec_->GetOutputSize(&size_) != media::MEDIA_CODEC_OK) {
+        if (media_codec_->GetOutputSize(&size_) != MEDIA_CODEC_OK) {
           POST_ERROR(PLATFORM_FAILURE, "GetOutputSize failed.");
           return false;
         }
 
         DVLOG(3) << __FUNCTION__
                  << " OUTPUT_FORMAT_CHANGED, new size: " << size_.ToString();
 
         // Don't request picture buffers if we already have some. This avoids
         // having to dismiss the existing buffers which may actively reference
         // decoded images. Breaking their connection to the decoded image will
         // cause rendering of black frames. Instead, we let the existing
         // PictureBuffers live on and we simply update their size the next time
         // they're attachted to an image of the new resolution. See the
         // size update in |SendDecodedFrameToClient| and https://crbug/587994.
         if (output_picture_buffers_.empty() && !picturebuffers_requested_) {
           picturebuffers_requested_ = true;
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&AndroidVideoDecodeAccelerator::RequestPictureBuffers,
                          weak_this_factory_.GetWeakPtr()));
           return false;
         }
 
         return true;
       }
 
-      case media::MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
+      case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
         break;
 
-      case media::MEDIA_CODEC_OK:
+      case MEDIA_CODEC_OK:
         DCHECK_GE(buf_index, 0);
         DVLOG(3) << __FUNCTION__ << ": pts:" << presentation_timestamp
                  << " buf_index:" << buf_index << " offset:" << offset
                  << " size:" << size << " eos:" << eos;
         break;
 
       default:
         NOTREACHED();
         break;
     }
@@ skipping 83 matching lines @@
 
   bool size_changed = false;
   if (i->second.size() != size_) {
     // Size may have changed due to resolution change since the last time this
     // PictureBuffer was used.
     strategy_->UpdatePictureBufferSize(&i->second, size_);
     size_changed = true;
   }
 
   const bool allow_overlay = strategy_->ArePicturesOverlayable();
-  media::Picture picture(picture_buffer_id, bitstream_id, gfx::Rect(size_),
-                         allow_overlay);
+  Picture picture(picture_buffer_id, bitstream_id, gfx::Rect(size_),
+                  allow_overlay);
   picture.set_size_changed(size_changed);
 
   // Notify picture ready before calling UseCodecBufferForPictureBuffer() since
   // that process may be slow and shouldn't delay delivery of the frame to the
   // renderer. The picture is only used on the same thread as this method is
   // called, so it is safe to do this.
   NotifyPictureReady(picture);
 
   // Connect the PictureBuffer to the decoded frame, via whatever mechanism the
   // strategy likes.
   strategy_->UseCodecBufferForPictureBuffer(codec_buffer_index, i->second);
 }
 
 void AndroidVideoDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If we previously deferred a codec restart, take care of it now. This can
   // happen on older devices where configuration changes require a codec reset.
   if (codec_needs_reset_) {
     DCHECK_EQ(drain_type_, DRAIN_TYPE_NONE);
     ResetCodecState();
   }
 
   if (bitstream_buffer.id() >= 0 && bitstream_buffer.size() > 0) {
     DecodeBuffer(bitstream_buffer);
     return;
   }
 
   if (base::SharedMemory::IsHandleValid(bitstream_buffer.handle()))
     base::SharedMemory::CloseHandle(bitstream_buffer.handle());
 
   if (bitstream_buffer.id() < 0) {
     POST_ERROR(INVALID_ARGUMENT,
                "Invalid bistream_buffer, id: " << bitstream_buffer.id());
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                    weak_this_factory_.GetWeakPtr(), bitstream_buffer.id()));
   }
 }
 
 void AndroidVideoDecodeAccelerator::DecodeBuffer(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   pending_bitstream_records_.push(BitstreamRecord(bitstream_buffer));
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
                  pending_bitstream_records_.size());
 
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::RequestPictureBuffers() {
   if (client_) {
     client_->ProvidePictureBuffers(kNumPictureBuffers, PIXEL_FORMAT_UNKNOWN, 1,
                                    strategy_->GetPictureBufferSize(),
                                    strategy_->GetTextureTarget());
   }
 }
 
 void AndroidVideoDecodeAccelerator::AssignPictureBuffers(
-    const std::vector<media::PictureBuffer>& buffers) {
+    const std::vector<PictureBuffer>& buffers) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(output_picture_buffers_.empty());
   DCHECK(free_picture_ids_.empty());
 
   if (buffers.size() < kNumPictureBuffers) {
     POST_ERROR(INVALID_ARGUMENT, "Not enough picture buffers assigned.");
     return;
   }
 
   const bool have_context = make_context_current_cb_.Run();
@@ skipping 75 matching lines @@
   base::PostTaskAndReplyWithResult(
       task_runner.get(), FROM_HERE,
       base::Bind(&AndroidVideoDecodeAccelerator::ConfigureMediaCodecOnAnyThread,
                  codec_config_),
       base::Bind(&AndroidVideoDecodeAccelerator::OnCodecConfigured,
                  weak_this_factory_.GetWeakPtr()));
 }
 
 bool AndroidVideoDecodeAccelerator::ConfigureMediaCodecSynchronously() {
   state_ = WAITING_FOR_CODEC;
-  std::unique_ptr<media::VideoCodecBridge> media_codec =
+  std::unique_ptr<VideoCodecBridge> media_codec =
       ConfigureMediaCodecOnAnyThread(codec_config_);
   OnCodecConfigured(std::move(media_codec));
   return !!media_codec_;
 }
 
-std::unique_ptr<media::VideoCodecBridge>
+std::unique_ptr<VideoCodecBridge>
 AndroidVideoDecodeAccelerator::ConfigureMediaCodecOnAnyThread(
     scoped_refptr<CodecConfig> codec_config) {
   TRACE_EVENT0("media", "AVDA::ConfigureMediaCodec");
 
   jobject media_crypto = codec_config->media_crypto_
                              ? codec_config->media_crypto_->obj()
                              : nullptr;
 
   // |needs_protected_surface_| implies encrypted stream.
   DCHECK(!codec_config->needs_protected_surface_ || media_crypto);
 
-  return std::unique_ptr<media::VideoCodecBridge>(
-      media::VideoCodecBridge::CreateDecoder(
-          codec_config->codec_, codec_config->needs_protected_surface_,
-          codec_config->initial_expected_coded_size_,
-          codec_config->surface_.j_surface().obj(), media_crypto, true));
+  return std::unique_ptr<VideoCodecBridge>(VideoCodecBridge::CreateDecoder(
+      codec_config->codec_, codec_config->needs_protected_surface_,
+      codec_config->initial_expected_coded_size_,
+      codec_config->surface_.j_surface().obj(), media_crypto, true));
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
-    std::unique_ptr<media::VideoCodecBridge> media_codec) {
+    std::unique_ptr<VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // Record one instance of the codec being initialized.
   RecordFormatChangedMetric(FormatChangedValue::CodecInitialized);
 
   // If we are supposed to notify that initialization is complete, then do so
   // now.  Otherwise, this is a reconfiguration.
   if (deferred_initialization_pending_) {
     // Losing the output surface is not considered an error state, so notify
@@ skipping 28 matching lines @@
   // another drain request is present, but DRAIN_FOR_DESTROY can.
   DCHECK_NE(drain_type, DRAIN_TYPE_NONE);
   DCHECK(drain_type_ == DRAIN_TYPE_NONE || drain_type == DRAIN_FOR_DESTROY)
       << "Unexpected StartCodecDrain() with drain type " << drain_type
       << " while already draining with drain type " << drain_type_;
 
   const bool enqueue_eos = drain_type_ == DRAIN_TYPE_NONE;
   drain_type_ = drain_type;
 
   if (enqueue_eos)
-    DecodeBuffer(media::BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
+    DecodeBuffer(BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
 }
 
 bool AndroidVideoDecodeAccelerator::IsDrainingForResetOrDestroy() const {
   return drain_type_ == DRAIN_FOR_RESET || drain_type_ == DRAIN_FOR_DESTROY;
 }
 
 void AndroidVideoDecodeAccelerator::OnDrainCompleted() {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 112 matching lines @@
   bitstreams_notified_in_advance_.clear();
 
   // Any error that is waiting to post can be ignored.
   error_sequence_token_++;
 
   DCHECK(strategy_);
   strategy_->ReleaseCodecBuffers(output_picture_buffers_);
 
   // Some VP8 files require complete MediaCodec drain before we can call
   // MediaCodec.flush() or MediaCodec.reset(). http://crbug.com/598963.
-  if (media_codec_ && codec_config_->codec_ == media::kCodecVP8) {
+  if (media_codec_ && codec_config_->codec_ == kCodecVP8) {
     // Postpone ResetCodecState() after the drain.
     StartCodecDrain(DRAIN_FOR_RESET);
   } else {
     ResetCodecState();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
                               weak_this_factory_.GetWeakPtr()));
   }
 }
 
@@ skipping 11 matching lines @@
   // If we have an OnFrameAvailable handler, tell it that we're going away.
   if (on_frame_available_handler_) {
     on_frame_available_handler_->ClearOwner();
     on_frame_available_handler_ = nullptr;
   }
 
   client_ = nullptr;
 
   // Some VP8 files require complete MediaCodec drain before we can call
   // MediaCodec.flush() or MediaCodec.reset(). http://crbug.com/598963.
-  if (media_codec_ && codec_config_->codec_ == media::kCodecVP8) {
+  if (media_codec_ && codec_config_->codec_ == kCodecVP8) {
     // Clear pending_bitstream_records_.
     while (!pending_bitstream_records_.empty())
       pending_bitstream_records_.pop();
 
     // Postpone ActualDestroy after the drain.
     StartCodecDrain(DRAIN_FOR_DESTROY);
   } else {
     ActualDestroy();
   }
 }
@@ skipping 36 matching lines @@
     const {
   return thread_checker_;
 }
 
 base::WeakPtr<gpu::gles2::GLES2Decoder>
 AndroidVideoDecodeAccelerator::GetGlDecoder() const {
   return get_gles2_decoder_cb_.Run();
 }
 
 gpu::gles2::TextureRef* AndroidVideoDecodeAccelerator::GetTextureForPicture(
-    const media::PictureBuffer& picture_buffer) {
+    const PictureBuffer& picture_buffer) {
   auto gles_decoder = GetGlDecoder();
   RETURN_ON_FAILURE(this, gles_decoder, "Failed to get GL decoder",
                     ILLEGAL_STATE, nullptr);
   RETURN_ON_FAILURE(this, gles_decoder->GetContextGroup(),
                     "Null gles_decoder->GetContextGroup()", ILLEGAL_STATE,
                     nullptr);
   gpu::gles2::TextureManager* texture_manager =
       gles_decoder->GetContextGroup()->texture_manager();
   RETURN_ON_FAILURE(this, texture_manager, "Null texture_manager",
                     ILLEGAL_STATE, nullptr);
@@ skipping 58 matching lines @@
 }
 
 void AndroidVideoDecodeAccelerator::OnFrameAvailable() {
   // Remember: this may be on any thread.
   DCHECK(strategy_);
   strategy_->OnFrameAvailable();
 }
 
 void AndroidVideoDecodeAccelerator::PostError(
     const ::tracked_objects::Location& from_here,
-    media::VideoDecodeAccelerator::Error error) {
+    VideoDecodeAccelerator::Error error) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       from_here,
       base::Bind(&AndroidVideoDecodeAccelerator::NotifyError,
                  weak_this_factory_.GetWeakPtr(), error, error_sequence_token_),
       (defer_errors_ ? ErrorPostingDelay() : base::TimeDelta()));
   state_ = ERROR;
 }
 
 void AndroidVideoDecodeAccelerator::InitializeCdm() {
   DVLOG(2) << __FUNCTION__ << ": " << config_.cdm_id;
 
 #if !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   NOTIMPLEMENTED();
   NotifyInitializationComplete(false);
 #else
   // Store the CDM to hold a reference to it.
   cdm_for_reference_holding_only_ =
-      media::MojoCdmService::LegacyGetCdm(config_.cdm_id);
+      MojoCdmService::LegacyGetCdm(config_.cdm_id);
   DCHECK(cdm_for_reference_holding_only_);
 
   // On Android platform the CdmContext must be a MediaDrmBridgeCdmContext.
-  media_drm_bridge_cdm_context_ = static_cast<media::MediaDrmBridgeCdmContext*>(
+  media_drm_bridge_cdm_context_ = static_cast<MediaDrmBridgeCdmContext*>(
       cdm_for_reference_holding_only_->GetCdmContext());
   DCHECK(media_drm_bridge_cdm_context_);
 
   // Register CDM callbacks. The callbacks registered will be posted back to
   // this thread via BindToCurrentLoop.
 
   // Since |this| holds a reference to the |cdm_|, by the time the CDM is
   // destructed, UnregisterPlayer() must have been called and |this| has been
   // destructed as well. So the |cdm_unset_cb| will never have a chance to be
   // called.
   // TODO(xhwang): Remove |cdm_unset_cb| after it's not used on all platforms.
   cdm_registration_id_ = media_drm_bridge_cdm_context_->RegisterPlayer(
-      media::BindToCurrentLoop(
-          base::Bind(&AndroidVideoDecodeAccelerator::OnKeyAdded,
-                     weak_this_factory_.GetWeakPtr())),
+      BindToCurrentLoop(base::Bind(&AndroidVideoDecodeAccelerator::OnKeyAdded,
+                                   weak_this_factory_.GetWeakPtr())),
       base::Bind(&base::DoNothing));
 
   // Deferred initialization will continue in OnMediaCryptoReady().
-  media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(media::BindToCurrentLoop(
+  media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(BindToCurrentLoop(
       base::Bind(&AndroidVideoDecodeAccelerator::OnMediaCryptoReady,
                  weak_this_factory_.GetWeakPtr())));
 #endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 void AndroidVideoDecodeAccelerator::OnMediaCryptoReady(
-    media::MediaDrmBridgeCdmContext::JavaObjectPtr media_crypto,
+    MediaDrmBridgeCdmContext::JavaObjectPtr media_crypto,
     bool needs_protected_surface) {
   DVLOG(1) << __FUNCTION__;
 
   if (!media_crypto) {
     LOG(ERROR) << "MediaCrypto is not available, can't play encrypted stream.";
     cdm_for_reference_holding_only_ = nullptr;
     media_drm_bridge_cdm_context_ = nullptr;
     NotifyInitializationComplete(false);
     return;
   }
@@ skipping 18 matching lines @@
     state_ = NO_ERROR;
 
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyInitializationComplete(bool success) {
   if (client_)
     client_->NotifyInitializationComplete(success);
 }
 
-void AndroidVideoDecodeAccelerator::NotifyPictureReady(
-    const media::Picture& picture) {
+void AndroidVideoDecodeAccelerator::NotifyPictureReady(const Picture& picture) {
   if (client_)
     client_->PictureReady(picture);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int input_buffer_id) {
   if (client_)
     client_->NotifyEndOfBitstreamBuffer(input_buffer_id);
 }
 
 void AndroidVideoDecodeAccelerator::NotifyFlushDone() {
   if (client_)
     client_->NotifyFlushDone();
 }
 
 void AndroidVideoDecodeAccelerator::NotifyResetDone() {
   if (client_)
     client_->NotifyResetDone();
 }
 
 void AndroidVideoDecodeAccelerator::NotifyError(
-    media::VideoDecodeAccelerator::Error error,
+    VideoDecodeAccelerator::Error error,
     int token) {
   DVLOG(1) << __FUNCTION__ << ": error: " << error << " token: " << token
            << " current: " << error_sequence_token_;
   if (token != error_sequence_token_)
     return;
 
   if (client_)
     client_->NotifyError(error);
 }
 
@@ skipping 19 matching lines @@
 
 // static
 bool AndroidVideoDecodeAccelerator::UseDeferredRenderingStrategy(
     const gpu::GpuPreferences& gpu_preferences) {
   // TODO(liberato, watk): Figure out what we want to do about zero copy for
   // fullscreen external SurfaceView in WebView.  http://crbug.com/582170.
   return !gpu_preferences.enable_threaded_texture_mailboxes;
 }
 
 // static
-media::VideoDecodeAccelerator::Capabilities
+VideoDecodeAccelerator::Capabilities
 AndroidVideoDecodeAccelerator::GetCapabilities(
     const gpu::GpuPreferences& gpu_preferences) {
   Capabilities capabilities;
   SupportedProfiles& profiles = capabilities.supported_profiles;
 
   // Only support VP8 on Android versions where we don't have to synchronously
   // tear down the MediaCodec on surface destruction because VP8 requires
   // us to completely drain the decoder before releasing it, which is difficult
   // and time consuming to do while the surface is being destroyed.
   if (base::android::BuildInfo::GetInstance()->sdk_int() >= 18 &&
-      media::MediaCodecUtil::IsVp8DecoderAvailable()) {
+      MediaCodecUtil::IsVp8DecoderAvailable()) {
     SupportedProfile profile;
-    profile.profile = media::VP8PROFILE_ANY;
+    profile.profile = VP8PROFILE_ANY;
     profile.min_resolution.SetSize(0, 0);
     profile.max_resolution.SetSize(3840, 2160);
     // If we know MediaCodec will just create a software codec, prefer our
     // internal software decoder instead. It's more up to date and secured
     // within the renderer sandbox. However if the content is encrypted, we
     // must use MediaCodec anyways since MediaDrm offers no way to decrypt
     // the buffers and let us use our internal software decoders.
-    profile.encrypted_only = media::VideoCodecBridge::IsKnownUnaccelerated(
-        media::kCodecVP8, media::MEDIA_CODEC_DECODER);
+    profile.encrypted_only =
+        VideoCodecBridge::IsKnownUnaccelerated(kCodecVP8, MEDIA_CODEC_DECODER);
     profiles.push_back(profile);
   }
 
-  if (media::MediaCodecUtil::IsVp9DecoderAvailable()) {
+  if (MediaCodecUtil::IsVp9DecoderAvailable()) {
     SupportedProfile profile;
     profile.min_resolution.SetSize(0, 0);
     profile.max_resolution.SetSize(3840, 2160);
     // If we know MediaCodec will just create a software codec, prefer our
     // internal software decoder instead. It's more up to date and secured
     // within the renderer sandbox. However if the content is encrypted, we
     // must use MediaCodec anyways since MediaDrm offers no way to decrypt
     // the buffers and let us use our internal software decoders.
-    profile.encrypted_only = media::VideoCodecBridge::IsKnownUnaccelerated(
-        media::kCodecVP9, media::MEDIA_CODEC_DECODER);
-    profile.profile = media::VP9PROFILE_PROFILE0;
+    profile.encrypted_only =
+        VideoCodecBridge::IsKnownUnaccelerated(kCodecVP9, MEDIA_CODEC_DECODER);
+    profile.profile = VP9PROFILE_PROFILE0;
     profiles.push_back(profile);
-    profile.profile = media::VP9PROFILE_PROFILE1;
+    profile.profile = VP9PROFILE_PROFILE1;
     profiles.push_back(profile);
-    profile.profile = media::VP9PROFILE_PROFILE2;
+    profile.profile = VP9PROFILE_PROFILE2;
     profiles.push_back(profile);
-    profile.profile = media::VP9PROFILE_PROFILE3;
+    profile.profile = VP9PROFILE_PROFILE3;
     profiles.push_back(profile);
   }
 
   for (const auto& supported_profile : kSupportedH264Profiles) {
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(0, 0);
     // Advertise support for 4k and let the MediaCodec fail when decoding if it
     // doesn't support the resolution. It's assumed that consumers won't have
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 
-  capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
-      SUPPORTS_DEFERRED_INITIALIZATION;
+  capabilities.flags =
+      VideoDecodeAccelerator::Capabilities::SUPPORTS_DEFERRED_INITIALIZATION;
   if (UseDeferredRenderingStrategy(gpu_preferences)) {
-    capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
+    capabilities.flags |= VideoDecodeAccelerator::Capabilities::
         NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
-    if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
-      capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
+    if (MediaCodecUtil::IsSurfaceViewOutputSupported()) {
+      capabilities.flags |= VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media