Removed NOTIFY_ERROR() macro from GpuVEAH.

content/common/gpu/client/gpu_video_encode_accelerator_host.cc

 // Copyright 2013 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/client/gpu_video_encode_accelerator_host.h"
 
+#include "base/location.h"
 #include "base/logging.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/media/gpu_video_accelerator_util.h"
 #include "media/base/video_frame.h"
 
 namespace content {
 
-#define NOTIFY_ERROR(error) \
-  PostNotifyError(error);   \
-  DLOG(ERROR)
-
 GpuVideoEncodeAcceleratorHost::GpuVideoEncodeAcceleratorHost(
     GpuChannelHost* channel,
     CommandBufferProxyImpl* impl)
     : channel_(channel),
       encoder_route_id_(MSG_ROUTING_NONE),
       client_(NULL),
       impl_(impl),
       next_frame_id_(0),
       weak_this_factory_(this) {
   DCHECK(channel_);
@@ skipping 29 matching lines @@
   return handled;
 }
 
 void GpuVideoEncodeAcceleratorHost::OnChannelError() {
   DCHECK(CalledOnValidThread());
   if (channel_) {
     if (encoder_route_id_ != MSG_ROUTING_NONE)
       channel_->RemoveRoute(encoder_route_id_);
     channel_ = NULL;
   }
-  NOTIFY_ERROR(kPlatformFailureError) << "OnChannelError()";
+  PostNotifyError(FROM_HERE, kPlatformFailureError, "OnChannelError()");
 }
 
 media::VideoEncodeAccelerator::SupportedProfiles
 GpuVideoEncodeAcceleratorHost::GetSupportedProfiles() {
   DCHECK(CalledOnValidThread());
   if (!channel_)
     return media::VideoEncodeAccelerator::SupportedProfiles();
   return GpuVideoAcceleratorUtil::ConvertGpuToMediaEncodeProfiles(
       channel_->gpu_info().video_encode_accelerator_supported_profiles);
 }
@@ skipping 28 matching lines @@
 }
 
 void GpuVideoEncodeAcceleratorHost::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DCHECK(CalledOnValidThread());
   if (!channel_)
     return;
 
   if (!base::SharedMemory::IsHandleValid(frame->shared_memory_handle())) {
-    NOTIFY_ERROR(kPlatformFailureError) << "EncodeSharedMemory(): cannot "
-                                           "encode frame with invalid shared "
-                                           "memory handle";
+    PostNotifyError(FROM_HERE, kPlatformFailureError,
+                    "EncodeSharedMemory(): cannot encode frame with "
+                    "invalid shared memory handle");
     return;
   }
 
   AcceleratedVideoEncoderMsg_Encode_Params params;
   params.frame_id = next_frame_id_;
   params.buffer_handle =
       channel_->ShareToGpuProcess(frame->shared_memory_handle());
   if (!base::SharedMemory::IsHandleValid(params.buffer_handle)) {
-    NOTIFY_ERROR(kPlatformFailureError) << "EncodeSharedMemory(): failed to "
-                                           "duplicate buffer handle for GPU "
-                                           "process";
+    PostNotifyError(FROM_HERE, kPlatformFailureError,
+                    "EncodeSharedMemory(): failed to duplicate buffer handle "
+                    "for GPU process");
     return;
   }
   params.buffer_offset =
       base::checked_cast<uint32_t>(frame->shared_memory_offset());
   // We assume that planar frame data passed here is packed and contiguous.
   base::CheckedNumeric<uint32_t> buffer_size = 0u;
   for (size_t i = 0; i < media::VideoFrame::NumPlanes(frame->format()); ++i) {
     // Cast DCHECK parameters to void* to avoid printing uint8* as a string.
     DCHECK_EQ(
         reinterpret_cast<void*>(frame->data(i)),
@@ skipping 14 matching lines @@
 
 void GpuVideoEncodeAcceleratorHost::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DCHECK(CalledOnValidThread());
   if (!channel_)
     return;
 
   base::SharedMemoryHandle handle =
       channel_->ShareToGpuProcess(buffer.handle());
   if (!base::SharedMemory::IsHandleValid(handle)) {
-    NOTIFY_ERROR(kPlatformFailureError)
-        << "UseOutputBitstreamBuffer(): failed to duplicate buffer handle "
-           "for GPU process: buffer.id()=" << buffer.id();
+    PostNotifyError(
+        FROM_HERE, kPlatformFailureError,
+        base::StringPrintf("UseOutputBitstreamBuffer(): failed to duplicate "
+                           "buffer handle for GPU process: buffer.id()=%d",
+                           buffer.id()));
     return;
   }
   Send(new AcceleratedVideoEncoderMsg_UseOutputBitstreamBuffer(
       encoder_route_id_, buffer.id(), handle, buffer.size()));
 }
 
 void GpuVideoEncodeAcceleratorHost::RequestEncodingParametersChange(
     uint32 bitrate,
     uint32 framerate) {
   DCHECK(CalledOnValidThread());
@@ skipping 13 matching lines @@
 }
 
 void GpuVideoEncodeAcceleratorHost::OnWillDeleteImpl() {
   DCHECK(CalledOnValidThread());
   impl_ = NULL;
 
   // The CommandBufferProxyImpl is going away; error out this VEA.
   OnChannelError();
 }
 
-void GpuVideoEncodeAcceleratorHost::PostNotifyError(Error error) {
+void GpuVideoEncodeAcceleratorHost::PostNotifyError(
+    const tracked_objects::Location& location, Error error,
+    const std::string& message) {
   DCHECK(CalledOnValidThread());
-  DVLOG(2) << "PostNotifyError(): error=" << error;
+  DLOG(ERROR) << "Error from " << location.function_name()
+              << "(" << location.file_name() << ":"
+              << location.line_number() << ") "
+              << message << " (error = " << error << ")";
   // Post the error notification back to this thread, to avoid re-entrancy.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&GpuVideoEncodeAcceleratorHost::OnNotifyError,
                             weak_this_factory_.GetWeakPtr(), error));
 }
 
 void GpuVideoEncodeAcceleratorHost::Send(IPC::Message* message) {
   DCHECK(CalledOnValidThread());
   uint32 message_type = message->type();
   if (!channel_->Send(message)) {
-    NOTIFY_ERROR(kPlatformFailureError) << "Send(" << message_type
-                                        << ") failed";
+    PostNotifyError(FROM_HERE, kPlatformFailureError,
+                    base::StringPrintf("Send(%d) failed", message_type));
   }
 }
 
 void GpuVideoEncodeAcceleratorHost::OnRequireBitstreamBuffers(
     uint32 input_count,
     const gfx::Size& input_coded_size,
     uint32 output_buffer_size) {
   DCHECK(CalledOnValidThread());
   DVLOG(2) << "OnRequireBitstreamBuffers(): input_count=" << input_count
            << ", input_coded_size=" << input_coded_size.ToString()
@@ skipping 45 matching lines @@
   weak_this_factory_.InvalidateWeakPtrs();
 
   // Client::NotifyError() may Destroy() |this|, so calling it needs to be the
   // last thing done on this stack!
   media::VideoEncodeAccelerator::Client* client = NULL;
   std::swap(client_, client);
   client->NotifyError(error);
 }
 
 }  // namespace content