Cleaning up src/media to be consistent with static versus anonymous namespaces.

media/video/mft_h264_decode_engine.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/video/mft_h264_decode_engine.h"
 
 #include <d3d9.h>
 #include <dxva2api.h>
 #include <initguid.h>
 #include <mfapi.h>
 // Placed after mfapi.h to avoid linking strmiids.lib for MR_BUFFER_SERVICE.
 #include <evr.h>
 #include <mferror.h>
 #include <wmcodecdsp.h>
 
 #include "base/time.h"
 #include "base/message_loop.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/video/video_decode_context.h"
 
 #pragma comment(lib, "dxva2.lib")
 #pragma comment(lib, "d3d9.lib")
 #pragma comment(lib, "mf.lib")
 #pragma comment(lib, "mfplat.lib")
 
 using base::TimeDelta;
 
-namespace {
+namespace media {
 
 // Creates an empty Media Foundation sample with no buffers.
 static IMFSample* CreateEmptySample() {
   HRESULT hr;
   ScopedComPtr<IMFSample> sample;
   hr = MFCreateSample(sample.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Unable to create an empty sample";
     return NULL;
   }
@@ skipping 85 matching lines @@
   CHECK(SUCCEEDED(buffer->Unlock()));
   hr = buffer->SetCurrentLength(size);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to set current length to " << size;
     return NULL;
   }
   VLOG(1) << __FUNCTION__ << " wrote " << size << " bytes into input sample";
   return sample.Detach();
 }
 
-const GUID ConvertVideoFrameFormatToGuid(media::VideoFrame::Format format) {
+const GUID ConvertVideoFrameFormatToGuid(VideoFrame::Format format) {
   switch (format) {
-    case media::VideoFrame::NV12:
+    case VideoFrame::NV12:
       return MFVideoFormat_NV12;
-    case media::VideoFrame::YV12:
+    case VideoFrame::YV12:
       return MFVideoFormat_YV12;
     default:
       NOTREACHED() << "Unsupported VideoFrame format";
       return GUID_NULL;
   }
   NOTREACHED();
   return GUID_NULL;
 }
 
-}  // namespace
-
-namespace media {
-
 // public methods
 
 MftH264DecodeEngine::MftH264DecodeEngine(bool use_dxva)
     : use_dxva_(use_dxva),
       state_(kUninitialized),
       event_handler_(NULL),
       context_(NULL) {
   memset(&input_stream_info_, 0, sizeof(input_stream_info_));
   memset(&output_stream_info_, 0, sizeof(output_stream_info_));
   memset(&config_, 0, sizeof(config_));
@@ skipping 519 matching lines @@
   uint8* dst_y = static_cast<uint8*>(frame->data(VideoFrame::kYPlane));
 
   memcpy(dst_y, src_y, current_length);
   CHECK(SUCCEEDED(output_buffer->Unlock()));
   event_handler_->ConsumeVideoFrame(frame, statistics);
   return true;
 }
 
 void MftH264DecodeEngine::OnUploadVideoFrameDone(
     ScopedComPtr<IDirect3DSurface9, &IID_IDirect3DSurface9> surface,
-    scoped_refptr<media::VideoFrame> frame,
+    scoped_refptr<VideoFrame> frame,
     PipelineStatistics statistics) {
   // After this method is exited the reference to surface is released.
   event_handler_->ConsumeVideoFrame(frame, statistics);
 }
 
 }  // namespace media
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(media::MftH264DecodeEngine);