PPAPI: Run clang_format.py on content/renderer/pepper

content/renderer/pepper/ppb_video_decoder_impl.cc

 // 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/renderer/pepper/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 23 matching lines @@
 using ppapi::thunk::PPB_Graphics3D_API;
 using ppapi::thunk::PPB_VideoDecoder_API;
 
 namespace {
 
 // Convert PP_VideoDecoder_Profile to media::VideoCodecProfile.
 media::VideoCodecProfile PPToMediaProfile(
     const PP_VideoDecoder_Profile pp_profile) {
   switch (pp_profile) {
     case PP_VIDEODECODER_H264PROFILE_NONE:
-      // HACK: PPAPI contains a bogus "none" h264 profile that doesn't
-      // correspond to anything in h.264; but a number of released chromium
-      // versions silently promoted this to Baseline profile, so we retain that
-      // behavior here.  Fall through.
+    // HACK: PPAPI contains a bogus "none" h264 profile that doesn't
+    // correspond to anything in h.264; but a number of released chromium
+    // versions silently promoted this to Baseline profile, so we retain that
+    // behavior here.  Fall through.
     case PP_VIDEODECODER_H264PROFILE_BASELINE:
       return media::H264PROFILE_BASELINE;
     case PP_VIDEODECODER_H264PROFILE_MAIN:
       return media::H264PROFILE_MAIN;
     case PP_VIDEODECODER_H264PROFILE_EXTENDED:
       return media::H264PROFILE_EXTENDED;
     case PP_VIDEODECODER_H264PROFILE_HIGH:
       return media::H264PROFILE_HIGH;
     case PP_VIDEODECODER_H264PROFILE_HIGH10PROFILE:
       return media::H264PROFILE_HIGH10PROFILE;
@@ skipping 12 matching lines @@
     case PP_VIDEODECODER_VP8PROFILE_MAIN:
       return media::VP8PROFILE_MAIN;
     default:
       return media::VIDEO_CODEC_PROFILE_UNKNOWN;
   }
 }
 
 PP_VideoDecodeError_Dev MediaToPPError(
     media::VideoDecodeAccelerator::Error error) {
   switch (error) {
-    case media::VideoDecodeAccelerator::ILLEGAL_STATE :
+    case media::VideoDecodeAccelerator::ILLEGAL_STATE:
       return PP_VIDEODECODERERROR_ILLEGAL_STATE;
-    case media::VideoDecodeAccelerator::INVALID_ARGUMENT :
+    case media::VideoDecodeAccelerator::INVALID_ARGUMENT:
       return PP_VIDEODECODERERROR_INVALID_ARGUMENT;
-    case media::VideoDecodeAccelerator::UNREADABLE_INPUT :
+    case media::VideoDecodeAccelerator::UNREADABLE_INPUT:
       return PP_VIDEODECODERERROR_UNREADABLE_INPUT;
-    case media::VideoDecodeAccelerator::PLATFORM_FAILURE :
+    case media::VideoDecodeAccelerator::PLATFORM_FAILURE:
       return PP_VIDEODECODERERROR_PLATFORM_FAILURE;
     default:
       NOTREACHED();
       return PP_VIDEODECODERERROR_ILLEGAL_STATE;
   }
 }
 
 }  // namespace
 
 namespace content {
 
 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PP_Instance instance)
-    : PPB_VideoDecoder_Shared(instance),
-      ppp_videodecoder_(NULL) {
+    : PPB_VideoDecoder_Shared(instance), ppp_videodecoder_(NULL) {
   PluginModule* plugin_module =
       HostGlobals::Get()->GetInstance(pp_instance())->module();
   if (plugin_module) {
     ppp_videodecoder_ = static_cast<const PPP_VideoDecoder_Dev*>(
         plugin_module->GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
   }
 }
 
-PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() {
-  Destroy();
-}
+PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() { Destroy(); }
 
 // static
-PP_Resource PPB_VideoDecoder_Impl::Create(
-    PP_Instance instance,
-    PP_Resource graphics_context,
-    PP_VideoDecoder_Profile profile) {
+PP_Resource PPB_VideoDecoder_Impl::Create(PP_Instance instance,
+                                          PP_Resource graphics_context,
+                                          PP_VideoDecoder_Profile profile) {
   EnterResourceNoLock<PPB_Graphics3D_API> enter_context(graphics_context, true);
   if (enter_context.failed())
     return 0;
   PPB_Graphics3D_Impl* graphics3d_impl =
       static_cast<PPB_Graphics3D_Impl*>(enter_context.object());
 
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       new PPB_VideoDecoder_Impl(instance));
-  if (decoder->Init(graphics_context, graphics3d_impl->platform_context(),
-                    graphics3d_impl->gles2_impl(), profile))
+  if (decoder->Init(graphics_context,
+                    graphics3d_impl->platform_context(),
+                    graphics3d_impl->gles2_impl(),
+                    profile))
     return decoder->GetReference();
   return 0;
 }
 
-bool PPB_VideoDecoder_Impl::Init(
-    PP_Resource graphics_context,
-    PlatformContext3D* context,
-    gpu::gles2::GLES2Implementation* gles2_impl,
-    PP_VideoDecoder_Profile profile) {
+bool PPB_VideoDecoder_Impl::Init(PP_Resource graphics_context,
+                                 PlatformContext3D* context,
+                                 gpu::gles2::GLES2Implementation* gles2_impl,
+                                 PP_VideoDecoder_Profile profile) {
   InitCommon(graphics_context, gles2_impl);
 
   int command_buffer_route_id = context->GetCommandBufferRouteId();
   if (command_buffer_route_id == 0)
     return false;
 
   platform_video_decoder_.reset(
       new PlatformVideoDecoder(command_buffer_route_id));
   if (!platform_video_decoder_)
     return false;
 
   FlushCommandBuffer();
   return platform_video_decoder_->Initialize(PPToMediaProfile(profile), this);
 }
 
 int32_t PPB_VideoDecoder_Impl::Decode(
     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
     scoped_refptr<TrackedCallback> callback) {
   if (!platform_video_decoder_)
     return PP_ERROR_BADRESOURCE;
 
   EnterResourceNoLock<PPB_Buffer_API> enter(bitstream_buffer->data, true);
   if (enter.failed())
     return PP_ERROR_FAILED;
 
   PPB_Buffer_Impl* buffer = static_cast<PPB_Buffer_Impl*>(enter.object());
   DCHECK_GE(bitstream_buffer->id, 0);
-  media::BitstreamBuffer decode_buffer(
-      bitstream_buffer->id,
-      buffer->shared_memory()->handle(),
-      bitstream_buffer->size);
+  media::BitstreamBuffer decode_buffer(bitstream_buffer->id,
+                                       buffer->shared_memory()->handle(),
+                                       bitstream_buffer->size);
   if (!SetBitstreamBufferCallback(bitstream_buffer->id, callback))
     return PP_ERROR_BADARGUMENT;
 
   FlushCommandBuffer();
   platform_video_decoder_->Decode(decode_buffer);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_VideoDecoder_Impl::AssignPictureBuffers(
     uint32_t no_of_buffers,
@@ skipping 63 matching lines @@
 }
 
 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
   if (!ppp_videodecoder_)
     return;
 
   PP_Size out_dim = PP_MakeSize(dimensions.width(), dimensions.height());
-  ppp_videodecoder_->ProvidePictureBuffers(pp_instance(), pp_resource(),
-      requested_num_of_buffers, &out_dim, texture_target);
+  ppp_videodecoder_->ProvidePictureBuffers(pp_instance(),
+                                           pp_resource(),
+                                           requested_num_of_buffers,
+                                           &out_dim,
+                                           texture_target);
 }
 
 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
   if (!ppp_videodecoder_)
     return;
 
   PP_Picture_Dev output;
   output.picture_buffer_id = picture.picture_buffer_id();
   output.bitstream_buffer_id = picture.bitstream_buffer_id();
   ppp_videodecoder_->PictureReady(pp_instance(), pp_resource(), &output);
 }
 
 void PPB_VideoDecoder_Impl::DismissPictureBuffer(int32 picture_buffer_id) {
   if (!ppp_videodecoder_)
     return;
-  ppp_videodecoder_->DismissPictureBuffer(pp_instance(), pp_resource(),
-                                          picture_buffer_id);
+  ppp_videodecoder_->DismissPictureBuffer(
+      pp_instance(), pp_resource(), picture_buffer_id);
 }
 
 void PPB_VideoDecoder_Impl::NotifyError(
     media::VideoDecodeAccelerator::Error error) {
   if (!ppp_videodecoder_)
     return;
 
   PP_VideoDecodeError_Dev pp_error = MediaToPPError(error);
   ppp_videodecoder_->NotifyError(pp_instance(), pp_resource(), pp_error);
-  UMA_HISTOGRAM_ENUMERATION(
-      "Media.PepperVideoDecoderError", error,
-      media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
+  UMA_HISTOGRAM_ENUMERATION("Media.PepperVideoDecoderError",
+                            error,
+                            media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
 }
 
-void PPB_VideoDecoder_Impl::NotifyResetDone() {
-  RunResetCallback(PP_OK);
-}
+void PPB_VideoDecoder_Impl::NotifyResetDone() { RunResetCallback(PP_OK); }
 
 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   RunBitstreamBufferCallback(bitstream_buffer_id, PP_OK);
 }
 
-void PPB_VideoDecoder_Impl::NotifyFlushDone() {
-  RunFlushCallback(PP_OK);
-}
+void PPB_VideoDecoder_Impl::NotifyFlushDone() { RunFlushCallback(PP_OK); }
 
 }  // namespace content