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

media/gpu/vp9_decoder.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 "media/gpu/vp9_decoder.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "media/base/limits.h"
 #include "media/gpu/vp9_decoder.h"
 
 namespace media {
 
 VP9Decoder::VP9Accelerator::VP9Accelerator() {}
 
 VP9Decoder::VP9Accelerator::~VP9Accelerator() {}
 
 VP9Decoder::VP9Decoder(VP9Accelerator* accelerator)
     : state_(kNeedStreamMetadata), accelerator_(accelerator) {
   DCHECK(accelerator_);
-  ref_frames_.resize(media::kVp9NumRefFrames);
+  ref_frames_.resize(kVp9NumRefFrames);
 }
 
 VP9Decoder::~VP9Decoder() {}
 
 void VP9Decoder::SetStream(const uint8_t* ptr, size_t size) {
   DCHECK(ptr);
   DCHECK(size);
 
   DVLOG(4) << "New input stream at: " << (void*)ptr << " size: " << size;
   parser_.SetStream(ptr, size);
@@ skipping 13 matching lines @@
   parser_.Reset();
 
   if (state_ == kDecoding)
     state_ = kAfterReset;
 }
 
 VP9Decoder::DecodeResult VP9Decoder::Decode() {
   while (1) {
     // Read a new frame header if one is not awaiting decoding already.
     if (!curr_frame_hdr_) {
-      std::unique_ptr<media::Vp9FrameHeader> hdr(new media::Vp9FrameHeader());
-      media::Vp9Parser::Result res = parser_.ParseNextFrame(hdr.get());
+      std::unique_ptr<Vp9FrameHeader> hdr(new Vp9FrameHeader());
+      Vp9Parser::Result res = parser_.ParseNextFrame(hdr.get());
       switch (res) {
-        case media::Vp9Parser::kOk:
+        case Vp9Parser::kOk:
           curr_frame_hdr_.reset(hdr.release());
           break;
 
-        case media::Vp9Parser::kEOStream:
+        case Vp9Parser::kEOStream:
           return kRanOutOfStreamData;
 
-        case media::Vp9Parser::kInvalidStream:
+        case Vp9Parser::kInvalidStream:
           DVLOG(1) << "Error parsing stream";
           SetError();
           return kDecodeError;
       }
     }
 
     if (state_ != kDecoding) {
       // Not kDecoding, so we need a resume point (a keyframe), as we are after
       // reset or at the beginning of the stream. Drop anything that is not
       // a keyframe in such case, and continue looking for a keyframe.
@@ skipping 57 matching lines @@
     pic->frame_hdr.reset(curr_frame_hdr_.release());
 
     if (!DecodeAndOutputPicture(pic)) {
       SetError();
       return kDecodeError;
     }
   }
 }
 
 void VP9Decoder::RefreshReferenceFrames(const scoped_refptr<VP9Picture>& pic) {
-  for (size_t i = 0; i < media::kVp9NumRefFrames; ++i) {
+  for (size_t i = 0; i < kVp9NumRefFrames; ++i) {
     DCHECK(!pic->frame_hdr->IsKeyframe() || pic->frame_hdr->RefreshFlag(i));
     if (pic->frame_hdr->RefreshFlag(i))
       ref_frames_[i] = pic;
   }
 }
 
 bool VP9Decoder::DecodeAndOutputPicture(scoped_refptr<VP9Picture> pic) {
   DCHECK(!pic_size_.IsEmpty());
   DCHECK(pic->frame_hdr);
 
@@ skipping 15 matching lines @@
   state_ = kError;
 }
 
 gfx::Size VP9Decoder::GetPicSize() const {
   return pic_size_;
 }
 
 size_t VP9Decoder::GetRequiredNumOfPictures() const {
   // kMaxVideoFrames to keep higher level media pipeline populated, +2 for the
   // pictures being parsed and decoded currently.
-  return media::limits::kMaxVideoFrames + media::kVp9NumRefFrames + 2;
+  return limits::kMaxVideoFrames + kVp9NumRefFrames + 2;
 }
 
 }  // namespace media