Don't make a top-level namespace called "internal"

webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_decoder.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  *
  */
 
 #include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_decoder.h"
 
 #include <memory>
 
 #if defined(WEBRTC_IOS)
 #include "RTCUIApplication.h"
 #endif
 #include "libyuv/convert.h"
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_video/include/corevideo_frame_buffer.h"
 #include "webrtc/sdk/objc/Framework/Classes/h264_video_toolbox_nalu.h"
 #include "webrtc/video_frame.h"
 
-namespace internal {
+namespace webrtc {
+namespace {
 
 static const int64_t kMsPerSec = 1000;
 
 // Convenience function for creating a dictionary.
 inline CFDictionaryRef CreateCFDictionary(CFTypeRef* keys,
                                           CFTypeRef* values,
                                           size_t size) {
   return CFDictionaryCreate(nullptr, keys, values, size,
                             &kCFTypeDictionaryKeyCallBacks,
                             &kCFTypeDictionaryValueCallBacks);
 }
 
 // Struct that we pass to the decoder per frame to decode. We receive it again
 // in the decoder callback.
 struct FrameDecodeParams {
-  FrameDecodeParams(webrtc::DecodedImageCallback* cb, int64_t ts)
+  FrameDecodeParams(DecodedImageCallback* cb, int64_t ts)
       : callback(cb), timestamp(ts) {}
-  webrtc::DecodedImageCallback* callback;
+  DecodedImageCallback* callback;
   int64_t timestamp;
 };
 
 // This is the callback function that VideoToolbox calls when decode is
 // complete.
 void VTDecompressionOutputCallback(void* decoder,
                                    void* params,
                                    OSStatus status,
                                    VTDecodeInfoFlags info_flags,
                                    CVImageBufferRef image_buffer,
                                    CMTime timestamp,
                                    CMTime duration) {
   std::unique_ptr<FrameDecodeParams> decode_params(
       reinterpret_cast<FrameDecodeParams*>(params));
   if (status != noErr) {
     LOG(LS_ERROR) << "Failed to decode frame. Status: " << status;
     return;
   }
   // TODO(tkchin): Handle CVO properly.
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
-      new rtc::RefCountedObject<webrtc::CoreVideoFrameBuffer>(image_buffer);
-  webrtc::VideoFrame decoded_frame(buffer, decode_params->timestamp,
-                                   CMTimeGetSeconds(timestamp) * kMsPerSec,
-                                   webrtc::kVideoRotation_0);
+  rtc::scoped_refptr<VideoFrameBuffer> buffer =
+      new rtc::RefCountedObject<CoreVideoFrameBuffer>(image_buffer);
+  VideoFrame decoded_frame(buffer, decode_params->timestamp,
+                           CMTimeGetSeconds(timestamp) * kMsPerSec,
+                           kVideoRotation_0);
   decode_params->callback->Decoded(decoded_frame);
 }
 
-}  // namespace internal
-
-namespace webrtc {
+}  // namespace
 
 H264VideoToolboxDecoder::H264VideoToolboxDecoder()
     : callback_(nullptr),
       video_format_(nullptr),
       decompression_session_(nullptr) {}
 
 H264VideoToolboxDecoder::~H264VideoToolboxDecoder() {
   DestroyDecompressionSession();
   SetVideoFormat(nullptr);
 }
@@ skipping 47 matching lines @@
   }
   CMSampleBufferRef sample_buffer = nullptr;
   if (!H264AnnexBBufferToCMSampleBuffer(input_image._buffer,
                                         input_image._length, video_format_,
                                         &sample_buffer)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   RTC_DCHECK(sample_buffer);
   VTDecodeFrameFlags decode_flags =
       kVTDecodeFrame_EnableAsynchronousDecompression;
-  std::unique_ptr<internal::FrameDecodeParams> frame_decode_params;
+  std::unique_ptr<FrameDecodeParams> frame_decode_params;
   frame_decode_params.reset(
-      new internal::FrameDecodeParams(callback_, input_image._timeStamp));
+      new FrameDecodeParams(callback_, input_image._timeStamp));
   OSStatus status = VTDecompressionSessionDecodeFrame(
       decompression_session_, sample_buffer, decode_flags,
       frame_decode_params.release(), nullptr);
 #if defined(WEBRTC_IOS)
   // Re-initialize the decoder if we have an invalid session while the app is
   // active and retry the decode request.
   if (status == kVTInvalidSessionErr &&
       ResetDecompressionSession() == WEBRTC_VIDEO_CODEC_OK) {
     frame_decode_params.reset(
-        new internal::FrameDecodeParams(callback_, input_image._timeStamp));
+        new FrameDecodeParams(callback_, input_image._timeStamp));
     status = VTDecompressionSessionDecodeFrame(
         decompression_session_, sample_buffer, decode_flags,
         frame_decode_params.release(), nullptr);
   }
 #endif
   CFRelease(sample_buffer);
   if (status != noErr) {
     LOG(LS_ERROR) << "Failed to decode frame with code: " << status;
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
@@ skipping 35 matching lines @@
   static size_t const attributes_size = 3;
   CFTypeRef keys[attributes_size] = {
 #if defined(WEBRTC_IOS)
     kCVPixelBufferOpenGLESCompatibilityKey,
 #elif defined(WEBRTC_MAC)
     kCVPixelBufferOpenGLCompatibilityKey,
 #endif
     kCVPixelBufferIOSurfacePropertiesKey,
     kCVPixelBufferPixelFormatTypeKey
   };
-  CFDictionaryRef io_surface_value =
-      internal::CreateCFDictionary(nullptr, nullptr, 0);
+  CFDictionaryRef io_surface_value = CreateCFDictionary(nullptr, nullptr, 0);
   int64_t nv12type = kCVPixelFormatType_420YpCbCr8BiPlanarFullRange;
   CFNumberRef pixel_format =
       CFNumberCreate(nullptr, kCFNumberLongType, &nv12type);
   CFTypeRef values[attributes_size] = {kCFBooleanTrue, io_surface_value,
                                        pixel_format};
   CFDictionaryRef attributes =
-      internal::CreateCFDictionary(keys, values, attributes_size);
+      CreateCFDictionary(keys, values, attributes_size);
   if (io_surface_value) {
     CFRelease(io_surface_value);
     io_surface_value = nullptr;
   }
   if (pixel_format) {
     CFRelease(pixel_format);
     pixel_format = nullptr;
   }
   VTDecompressionOutputCallbackRecord record = {
-      internal::VTDecompressionOutputCallback, this,
+      VTDecompressionOutputCallback, this,
   };
   OSStatus status =
       VTDecompressionSessionCreate(nullptr, video_format_, nullptr, attributes,
                                    &record, &decompression_session_);
   CFRelease(attributes);
   if (status != noErr) {
     DestroyDecompressionSession();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   ConfigureDecompressionSession();
@@ skipping 29 matching lines @@
   if (video_format_) {
     CFRetain(video_format_);
   }
 }
 
 const char* H264VideoToolboxDecoder::ImplementationName() const {
   return "VideoToolbox";
 }
 
 }  // namespace webrtc