Revert of media: Simplify {Audio|Video}Decoder initialization callback.

media/filters/gpu_video_decoder.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 "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 87 matching lines @@
 
 static bool IsCodedSizeSupported(const gfx::Size& coded_size,
                                  const gfx::Size& min_resolution,
                                  const gfx::Size& max_resolution) {
   return (coded_size.width() <= max_resolution.width() &&
       coded_size.height() <= max_resolution.height() &&
       coded_size.width() >= min_resolution.width() &&
       coded_size.height() >= min_resolution.height());
 }
 
-// Report |success| to UMA and run |cb| with it.  This is super-specific to the
+// Report |status| to UMA and run |cb| with it.  This is super-specific to the
 // UMA stat reported because the UMA_HISTOGRAM_ENUMERATION API requires a
 // callsite to always be called with the same stat name (can't parameterize it).
 static void ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB(
-    const VideoDecoder::InitCB& cb,
-    bool success) {
-  // TODO(xhwang): Report |success| directly.
-  PipelineStatus status = success ? PIPELINE_OK : DECODER_ERROR_NOT_SUPPORTED;
+    const PipelineStatusCB& cb,
+    PipelineStatus status) {
   UMA_HISTOGRAM_ENUMERATION(
       "Media.GpuVideoDecoderInitializeStatus", status, PIPELINE_STATUS_MAX + 1);
-  cb.Run(success);
+  cb.Run(status);
 }
 
 std::string GpuVideoDecoder::GetDisplayName() const {
   return kDecoderName;
 }
 
 void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  bool /* low_delay */,
-                                 const InitCB& init_cb,
+                                 const PipelineStatusCB& orig_status_cb,
                                  const OutputCB& output_cb) {
   DVLOG(3) << "Initialize()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(config.IsValidConfig());
   DCHECK(!config.is_encrypted());
 
-  InitCB bound_init_cb =
+  PipelineStatusCB status_cb =
       base::Bind(&ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB,
-                 BindToCurrentLoop(init_cb));
+                 BindToCurrentLoop(orig_status_cb));
 
   bool previously_initialized = config_.IsValidConfig();
   DVLOG(1) << "(Re)initializing GVD with config: "
            << config.AsHumanReadableString();
 
   // TODO(posciak): destroy and create a new VDA on codec/profile change
   // (http://crbug.com/260224).
   if (previously_initialized && (config_.profile() != config.profile())) {
     DVLOG(1) << "Codec or profile changed, cannot reinitialize.";
-    bound_init_cb.Run(false);
+    status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   if (!IsProfileSupported(config.profile(), config.coded_size())) {
-    bound_init_cb.Run(false);
+    status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   config_ = config;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
   output_cb_ = BindToCurrentLoop(output_cb);
 
   if (previously_initialized) {
     // Reinitialization with a different config (but same codec and profile).
     // VDA should handle it by detecting this in-stream by itself,
     // no need to notify it.
-    bound_init_cb.Run(true);
+    status_cb.Run(PIPELINE_OK);
     return;
   }
 
   vda_ = factories_->CreateVideoDecodeAccelerator().Pass();
   if (!vda_ || !vda_->Initialize(config.profile(), this)) {
-    bound_init_cb.Run(false);
+    status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   DVLOG(3) << "GpuVideoDecoder::Initialize() succeeded.";
-  bound_init_cb.Run(true);
+  status_cb.Run(PIPELINE_OK);
 }
 
 void GpuVideoDecoder::DestroyPictureBuffers(PictureBufferMap* buffers) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   for (PictureBufferMap::iterator it = buffers->begin(); it != buffers->end();
        ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
 
   buffers->clear();
@@ skipping 400 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media