Improve GPU tests to fail when GPU drawing fails

content/common/gpu/gpu_command_buffer_stub.cc

  // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 146 matching lines @@
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnInitialize(
     base::SharedMemoryHandle ring_buffer,
     int32 size,
     IPC::Message* reply_message) {
   DCHECK(!command_buffer_.get());
 
+  UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "TryCreateGLContext");
+
   command_buffer_.reset(new gpu::CommandBufferService);
 
 #if defined(OS_WIN)
   // Windows dups the shared memory handle it receives into the current process
   // and closes it when this variable goes out of scope.
   base::SharedMemory shared_memory(ring_buffer,
                                    false,
                                    channel_->renderer_process());
 #else
   // POSIX receives a dup of the shared memory handle and closes the dup when
   // this variable goes out of scope.
   base::SharedMemory shared_memory(ring_buffer, false);
 #endif
 
   if (!command_buffer_->Initialize(&shared_memory, size)) {
+    DLOG(ERROR) << "CommandBufferService failed to initialize.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group_.get()));
 
   scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
                                          decoder_.get(),
                                          NULL));
 
   decoder_->set_engine(scheduler_.get());
 
   if (handle_) {
 #if defined(OS_MACOSX) || defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
     if (software_) {
+      DLOG(ERROR) << "No software support.\n";
       OnInitializeFailed(reply_message);
       return;
     }
 #endif
 
     surface_ = ImageTransportSurface::CreateSurface(
         channel_->gpu_channel_manager(),
         render_view_id_,
         renderer_id_,
         route_id_,
@@ skipping 64 matching lines @@
 
   if (parent_stub_for_initialization_) {
     decoder_->SetParent(parent_stub_for_initialization_->decoder_.get(),
                         parent_texture_for_initialization_);
     parent_stub_for_initialization_.reset();
     parent_texture_for_initialization_ = 0;
   }
 
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, true);
   Send(reply_message);
+
+  UNSHIPPED_TRACE_EVENT_INSTANT1("test_gpu", "CreateGLContextSuccess",
+                                 "offscreen", surface_->IsOffscreen());
 }
 
 void GpuCommandBufferStub::OnSetParent(int32 parent_route_id,
                                        uint32 parent_texture_id,
                                        IPC::Message* reply_message) {
 
   GpuCommandBufferStub* parent_stub = NULL;
   if (parent_route_id != MSG_ROUTING_NONE) {
     parent_stub = channel_->LookupCommandBuffer(parent_route_id);
   }
@@ skipping 167 matching lines @@
 void GpuCommandBufferStub::OnDestroyVideoDecoder(int decoder_route_id) {
   channel_->RemoveRoute(decoder_route_id);
   video_decoders_.Remove(decoder_route_id);
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   surface_->SetVisible(visible);
 }
 
 #endif  // defined(ENABLE_GPU)