Fix ChromeOS (arm) use of WeakPtr<T>'s operator T* conversion

content/common/gpu/media/omx_video_decode_accelerator.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/common/gpu/media/omx_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 492 matching lines @@
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   current_state_change_ = FLUSHING;
 
   Decode(media::BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
 }
 
 void OmxVideoDecodeAccelerator::OnReachedEOSInFlushing() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   current_state_change_ = NO_TRANSITION;
-  if (client_)
+  if (client_.get())
     client_->NotifyFlushDone();
 }
 
 void OmxVideoDecodeAccelerator::FlushIOPorts() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
   // Flush input port first.
   if (!SendCommandToPort(OMX_CommandFlush, input_port_))
     return;
 }
@@ skipping 115 matching lines @@
   // dimension mismatch.
   for (std::set<OMX_BUFFERHEADERTYPE*>::iterator it =
            fake_output_buffers_.begin();
        it != fake_output_buffers_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* buffer = *it;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FillThisBuffer()", PLATFORM_FAILURE,);
     ++output_buffers_at_component_;
   }
 
-  if (client_)
+  if (client_.get())
     client_->NotifyInitializeDone();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedPauseInResetting() {
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   client_state_ = OMX_StatePause;
   FlushIOPorts();
 }
 
 void OmxVideoDecodeAccelerator::DecodeQueuedBitstreamBuffers() {
   BitstreamBufferList buffers;
   buffers.swap(queued_bitstream_buffers_);
   if (current_state_change_ == DESTROYING ||
       current_state_change_ == ERRORING) {
     return;
   }
   for (size_t i = 0; i < buffers.size(); ++i)
     Decode(buffers[i]);
 }
 
 void OmxVideoDecodeAccelerator::OnReachedExecutingInResetting() {
   DCHECK_EQ(client_state_, OMX_StatePause);
   client_state_ = OMX_StateExecuting;
   current_state_change_ = NO_TRANSITION;
-  if (!client_)
+  if (!client_.get())
     return;
 
   // Drain queues of input & output buffers held during the reset.
   DecodeQueuedBitstreamBuffers();
   for (size_t i = 0; i < queued_picture_buffer_ids_.size(); ++i)
     ReusePictureBuffer(queued_picture_buffer_ids_[i]);
   queued_picture_buffer_ids_.clear();
 
   client_->NotifyResetDone();
 }
@@ skipping 54 matching lines @@
   component_handle_ = NULL;
 }
 
 void OmxVideoDecodeAccelerator::StopOnError(
     media::VideoDecodeAccelerator::Error error) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
   if (current_state_change_ == ERRORING)
     return;
 
-  if (client_ && init_begun_)
+  if (client_.get() && init_begun_)
     client_->NotifyError(error);
   client_ptr_factory_.InvalidateWeakPtrs();
 
   if (client_state_ == OMX_StateInvalid || client_state_ == OMX_StateMax)
       return;
 
   BeginTransitionToState(OMX_StateInvalid);
   current_state_change_ = ERRORING;
 }
 
@@ skipping 78 matching lines @@
     DCHECK(omx_buffer);
     delete reinterpret_cast<media::Picture*>(omx_buffer->pAppPrivate);
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, omx_buffer);
     if (result != OMX_ErrorNone) {
       DLOG(ERROR) << "OMX_FreeBuffer failed: 0x" << std::hex << result;
       failure_seen = true;
     }
     texture_to_egl_image_translator_->DestroyEglImage(egl_display_,
                                                       it->second.egl_image);
-    if (client_)
+    if (client_.get())
       client_->DismissPictureBuffer(it->first);
   }
   pictures_.clear();
 
   // Delete pending fake_output_buffers_
   for (std::set<OMX_BUFFERHEADERTYPE*>::iterator it =
            fake_output_buffers_.begin();
        it != fake_output_buffers_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* buffer = *it;
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, buffer);
     if (result != OMX_ErrorNone) {
       DLOG(ERROR) << "OMX_FreeBuffer failed: 0x" << std::hex << result;
       failure_seen = true;
     }
   }
   fake_output_buffers_.clear();
 
   // Dequeue pending queued_picture_buffer_ids_
-  if (client_) {
+  if (client_.get()) {
     for (size_t i = 0; i < queued_picture_buffer_ids_.size(); ++i)
       client_->DismissPictureBuffer(queued_picture_buffer_ids_[i]);
   }
   queued_picture_buffer_ids_.clear();
 
   RETURN_ON_FAILURE(!failure_seen, "OMX_FreeBuffer", PLATFORM_FAILURE,);
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortDisabled() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   OMX_PARAM_PORTDEFINITIONTYPE port_format;
   InitParam(*this, &port_format);
   port_format.nPortIndex = output_port_;
   OMX_ERRORTYPE result = OMX_GetParameter(
       component_handle_, OMX_IndexParamPortDefinition, &port_format);
   RETURN_ON_OMX_FAILURE(result, "OMX_GetParameter", PLATFORM_FAILURE,);
   DCHECK_LE(port_format.nBufferCountMin, kNumPictureBuffers);
 
   // TODO(fischman): to support mid-stream resize, need to free/dismiss any
   // |pictures_| we already have.  Make sure that the shutdown-path agrees with
   // this (there's already freeing logic there, which should not be duplicated).
 
   // Request picture buffers to be handed to the component.
   // ProvidePictureBuffers() will trigger AssignPictureBuffers, which ultimately
   // assigns the textures to the component and re-enables the port.
   const OMX_VIDEO_PORTDEFINITIONTYPE& vformat = port_format.format.video;
   last_requested_picture_buffer_dimensions_.SetSize(vformat.nFrameWidth,
                                                     vformat.nFrameHeight);
-  if (client_) {
+  if (client_.get()) {
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
         gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight),
         GL_TEXTURE_2D);
   }
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortEnabled() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
@@ skipping 68 matching lines @@
   // During the transition from Executing to Idle, and during port-flushing, all
   // pictures are sent back through here.  Avoid giving them to the client.
   if (current_state_change_ == RESETTING) {
     queued_picture_buffer_ids_.push_back(picture_buffer_id);
     return;
   }
 
   DCHECK(picture);
   // See Decode() for an explanation of this abuse of nTimeStamp.
   picture->set_bitstream_buffer_id(buffer->nTimeStamp);
-  if (client_)
+  if (client_.get())
     client_->PictureReady(*picture);
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   TRACE_EVENT1("Video Decoder", "OVDA::EmptyBufferDoneTask",
                "Buffer id", buffer->nTimeStamp);
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   DCHECK_GT(input_buffers_at_component_, 0);
   free_input_buffers_.push(buffer);
   input_buffers_at_component_--;
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
     return;
 
   // Retrieve the corresponding BitstreamBuffer's id and notify the client of
   // its completion.
   SharedMemoryAndId* input_buffer_details =
       reinterpret_cast<SharedMemoryAndId*>(buffer->pAppPrivate);
   DCHECK(input_buffer_details);
   buffer->pAppPrivate = NULL;
-  if (client_)
+  if (client_.get())
     client_->NotifyEndOfBitstreamBuffer(input_buffer_details->second);
   delete input_buffer_details;
 
   DecodeQueuedBitstreamBuffers();
 }
 
 void OmxVideoDecodeAccelerator::DispatchStateReached(OMX_STATETYPE reached) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   switch (current_state_change_) {
     case INITIALIZING:
@@ skipping 232 matching lines @@
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         PLATFORM_FAILURE, false);
   return true;
 }
 
 }  // namespace content