Add tracing to early-outs of accelerated surface presents

ui/surface/accelerated_surface_win.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 "ui/surface/accelerated_surface_win.h"
 
 #include <dwmapi.h>
 #include <windows.h>
 #include <algorithm>
 
@@ skipping 671 matching lines @@
   HRESULT hr;
 
   base::AutoLock locked(lock_);
 
   // Initialize the device lazily since calling Direct3D can crash bots.
   present_thread_->InitDevice();
 
   if (!present_thread_->device()) {
     if (!completion_task.is_null())
       completion_task.Run(false, base::TimeTicks(), base::TimeDelta());
+    TRACE_EVENT0("gpu", "EarlyOut_NoDevice");
     return;
   }
 
   // Ensure the task is always run and while the lock is taken.
   base::ScopedClosureRunner scoped_completion_runner(
       base::Bind(completion_task, true, base::TimeTicks(), base::TimeDelta()));
 
   // If invalidated, do nothing, the window is gone.
-  if (!window_)
+  if (!window_) {
+    TRACE_EVENT0("gpu", "EarlyOut_NoWindow");
     return;
+  }
 
   // If the window is a different size than the swap chain that is being
   // presented then drop the frame.
   RECT window_rect;
   GetClientRect(window_, &window_rect);
   if (hidden_ && (window_rect.right != size.width() ||
       window_rect.bottom != size.height())) {
+    TRACE_EVENT2("gpu", "EarlyOut_WrongWindowSize",
+                 "backwidth", size.width(), "backheight", size.height());
+    TRACE_EVENT2("gpu", "EarlyOut_WrongWindowSize2",
+                 "windowwidth", window_rect.right,
+                 "windowheight", window_rect.bottom);
     return;
   }
 
   // Round up size so the swap chain is not continuously resized with the
   // surface, which could lead to memory fragmentation.
   const int kRound = 64;
   gfx::Size quantized_size(
       std::max(1, (size.width() + kRound - 1) / kRound * kRound),
       std::max(1, (size.height() + kRound - 1) / kRound * kRound));
 
@@ skipping 32 matching lines @@
                                                   D3DFMT_A8R8G8B8,
                                                   D3DPOOL_DEFAULT,
                                                   source_texture_.Receive(),
                                                   &handle);
     if (FAILED(hr))
       return;
   }
 
   base::win::ScopedComPtr<IDirect3DSurface9> source_surface;
   hr = source_texture_->GetSurfaceLevel(0, source_surface.Receive());
-  if (FAILED(hr))
+  if (FAILED(hr)) {
+    TRACE_EVENT0("gpu", "EarlyOut_NoSurfaceLevel");
     return;
+  }
 
   base::win::ScopedComPtr<IDirect3DSurface9> dest_surface;
   hr = swap_chain_->GetBackBuffer(0,
                                   D3DBACKBUFFER_TYPE_MONO,
                                   dest_surface.Receive());
-  if (FAILED(hr))
+  if (FAILED(hr)) {
+    TRACE_EVENT0("gpu", "EarlyOut_NoBackbuffer");
     return;
+  }
 
   RECT rect = {
     0, 0,
     size.width(), size.height()
   };
 
   {
     TRACE_EVENT0("gpu", "Copy");
 
     // Use a simple pixel / vertex shader pair to render a quad that flips the
@@ skipping 143 matching lines @@
   return presenter_->CopyTo(src_subrect, dst_size, buf);
 }
 
 void AcceleratedSurface::Suspend() {
   presenter_->Suspend();
 }
 
 void AcceleratedSurface::WasHidden() {
   presenter_->WasHidden();
 }