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/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()";
+  DLOG(ERROR) << "OnChannelError()";
+  PostNotifyError(kPlatformFailureError);
 }
 
 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";
+    DLOG(ERROR) << "EncodeSharedMemory(): cannot encode frame with "
+                   "invalid shared memory handle";
+    PostNotifyError(kPlatformFailureError);
     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";
+    DLOG(ERROR) << "EncodeSharedMemory(): failed to duplicate buffer handle "
+                   "for GPU process";
+    PostNotifyError(kPlatformFailureError);
     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();
+    DLOG(ERROR) << "UseOutputBitstreamBuffer(): failed to duplicate "
+                   "buffer handle for GPU process: buffer.id()=" << buffer.id();
+    PostNotifyError(kPlatformFailureError);
     return;
   }
   Send(new AcceleratedVideoEncoderMsg_UseOutputBitstreamBuffer(
       encoder_route_id_, buffer.id(), handle, buffer.size()));
 }
 
 void GpuVideoEncodeAcceleratorHost::RequestEncodingParametersChange(
     uint32 bitrate,
     uint32 framerate) {
   DCHECK(CalledOnValidThread());
@@ skipping 26 matching lines @@
   // 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";
+    DLOG(ERROR) << "Send(" << message_type << ") failed";
+    PostNotifyError(kPlatformFailureError);

[mcasas, 2015/09/30 15:32:07]

It's unfortunate that PostNotifyError(bla) is also doing a 
DLOG(ERROR) << bla 
[1] 

Maybe we could extend the method to do
PostNotifyError(Error error, const std::string& message)

and DLOG(ERROR) in that method. (Hint: in this case,
base::StringPrintf() is your friend to compose error strings).




[1]
https://code.google.com/p/chromium/codesearch#chromium/src/content/common/gpu...

[msu.koo, 2015/10/01 04:22:13]

DLOG comes with line number and file name. If we consolidate DLOG into
PostNotifyError, the line number of log will always indicate PostNotifyError
function. I think it would be better to notify the real error position by
leaving the DLOG as they are. WDYT?
 

[mcasas, 2015/10/05 16:18:48]

Yeah leaving the DLOG(ERROR) sounds logical, 
but then what's the use of a DVLOG(2) inside
PostnotifyError()? 

What about using class Location [1] and using it
as PostNotifyError() parameter? You can use then in
the call:
PostNotifyError(FROM_HERE, kBigErrorEnum)

and then inside PostNotifyError() print out a 
nice DLOG(ERROR), instead of a DVLOG(2).


[1]
https://code.google.com/p/chromium/codesearch#chromium/src/base/location.h&sq...

   }
 }
 
 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