Move a bunch of content\common code into the content namespace.

content/common/gpu/media/mac_video_decode_accelerator.mm

 // Copyright (c) 2012 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 "content/common/gpu/media/mac_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #import "base/mac/foundation_util.h"
 #import "base/memory/ref_counted_memory.h"
 #import "base/message_loop.h"
 #include "base/location.h"
 #include "base/native_library.h"
 #include "ui/surface/io_surface_support_mac.h"
 #include "ui/gfx/video_decode_acceleration_support_mac.h"
 
+namespace content {
+
 // Helper macros for dealing with failure.  If |result| evaluates false, emit
 // |log| to ERROR, register |error| with the decoder, and return |ret_val|
 // (which may be omitted for functions that return void).
 #define RETURN_ON_FAILURE(result, log, error, ret_val)             \
   do {                                                             \
     if (!(result)) {                                               \
       DLOG(ERROR) << log;                                          \
       StopOnError(error);                                          \
       return ret_val;                                              \
     }                                                              \
@@ skipping 93 matching lines @@
   RETURN_ON_FAILURE(client_,
                     "Call to Decode() during invalid state.", ILLEGAL_STATE,);
 
   base::SharedMemory memory(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(memory.Map(bitstream_buffer.size()),
                     "Failed to SharedMemory::Map().", UNREADABLE_INPUT,);
 
   h264_parser_.SetStream(static_cast<const uint8_t*>(memory.memory()),
                          bitstream_buffer.size());
   while (true) {
-    content::H264NALU nalu;
-    content::H264Parser::Result result = h264_parser_.AdvanceToNextNALU(&nalu);
-    if (result == content::H264Parser::kEOStream) {
+    H264NALU nalu;
+    H264Parser::Result result = h264_parser_.AdvanceToNextNALU(&nalu);
+    if (result == H264Parser::kEOStream) {
       if (bitstream_nalu_count_.count(bitstream_buffer.id()) == 0) {
         MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
             &MacVideoDecodeAccelerator::NotifyInputBufferRead,
             base::AsWeakPtr(this), bitstream_buffer.id()));
       }
       return;
     }
-    RETURN_ON_FAILURE(result == content::H264Parser::kOk,
+    RETURN_ON_FAILURE(result == H264Parser::kOk,
                       "Unable to parse bitstream.", UNREADABLE_INPUT,);
     if (!did_build_config_record_) {
       std::vector<uint8_t> config_record;
       RETURN_ON_FAILURE(config_record_builder_.ProcessNALU(&h264_parser_, nalu,
                                                            &config_record),
                         "Unable to build AVC configuraiton record.",
                         UNREADABLE_INPUT,);
       if (!config_record.empty()) {
         did_build_config_record_ = true;
         if (!CreateDecoder(config_record))
@@ skipping 150 matching lines @@
       &extra_data[0], extra_data.size());
   RETURN_ON_FAILURE(status == gfx::VideoDecodeAccelerationSupport::SUCCESS,
                     "Creating video decoder failed with error: " << status,
                     PLATFORM_FAILURE, false);
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &MacVideoDecodeAccelerator::RequestPictures, base::AsWeakPtr(this)));
   return true;
 }
 
-void MacVideoDecodeAccelerator::DecodeNALU(const content::H264NALU& nalu,
+void MacVideoDecodeAccelerator::DecodeNALU(const H264NALU& nalu,
                                            int32 bitstream_buffer_id) {
   // Assume the NALU length field size is 4 bytes.
   const int kNALULengthFieldSize = 4;
   std::vector<uint8_t> data(kNALULengthFieldSize + nalu.size);
 
   // Store the buffer size at the beginning of the buffer as the decoder
   // expects.
   for (size_t i = 0; i < kNALULengthFieldSize; ++i) {
     size_t shift = kNALULengthFieldSize * 8 - (i + 1) * 8;
     data[i] = (nalu.size >> shift) & 0xff;
@@ skipping 49 matching lines @@
 }
 
 MacVideoDecodeAccelerator::UsedPictureInfo::~UsedPictureInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::DecodedImageInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::~DecodedImageInfo() {
 }
+
+}  // namespace content