cc: Defer first OutputSurface creation until client is ready

chrome/test/gpu/gpu_feature_browsertest.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 "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/trace_event_analyzer.h"
@@ skipping 514 matching lines @@
     return;
 
   const base::FilePath url(
       FILE_PATH_LITERAL("feature_compositing_static.html"));
   base::FilePath test_path = gpu_test_dir_.Append(url);
   ASSERT_TRUE(base::PathExists(test_path))
       << "Missing test file: " << test_path.value();
 
   ui_test_utils::NavigateToURL(browser(), net::FilePathToFileURL(test_path));
 
+  LOG(INFO) << "did navigate";
   gfx::Rect bounds = browser()->window()->GetBounds();
   gfx::Rect new_bounds = bounds;
 
   const char* create_event = "IOSurfaceImageTransportSurface::CreateIOSurface";
   const char* resize_event = "IOSurfaceImageTransportSurface::OnResize";
   const char* draw_event = "CompositingIOSurfaceMac::DrawIOSurface";
   Query find_creates = Query::MatchBeginName(create_event);
   Query find_resizes = Query::MatchBeginName(resize_event) &&
                        Query::EventHasNumberArg("old_width") &&
                        Query::EventHasNumberArg("new_width");
   Query find_draws = Query::MatchBeginName(draw_event) &&
                      Query::EventHasNumberArg("scale");
 
   const int roundup = 64;
   // A few resize values assuming a roundup of 64 pixels. The test will resize
   // by these values one at a time and verify that CreateIOSurface only happens
   // when the rounded width changes.
   int offsets[] = { 1, roundup - 1, roundup, roundup + 1, 2*roundup};
   int num_offsets = static_cast<int>(arraysize(offsets));
   int w_start = bounds.width();
 
   for (int offset_i = 0; offset_i < num_offsets; ++offset_i) {
     new_bounds.set_width(w_start + offsets[offset_i]);
+    LOG(INFO) << "before wait";
     ASSERT_TRUE(ResizeAndWait(new_bounds, "gpu", "gpu", resize_event));
+    LOG(INFO) << "after wait";
 
     TraceEventVector resize_events;
     analyzer_->FindEvents(find_resizes, &resize_events);
+    LOG(INFO) << "num rezize events = " << resize_events.size();
     for (size_t resize_i = 0; resize_i < resize_events.size(); ++resize_i) {
       const trace_analyzer::TraceEvent* resize = resize_events[resize_i];
       // Was a create allowed:
       int old_width = resize->GetKnownArgAsInt("old_width");
       int new_width = resize->GetKnownArgAsInt("new_width");
       bool expect_create = (old_width/roundup != new_width/roundup ||
                             old_width == 0);
       int expected_creates = expect_create ? 1 : 0;
 
       // Find the create event inside this resize event (if any). This will
       // determine if the resize triggered a reallocation of the IOSurface.
       double begin_time = resize->timestamp;
       double end_time = begin_time + resize->GetAbsTimeToOtherEvent();
       Query find_this_create = find_creates &&
           Query::EventTime() >= Query::Double(begin_time) &&
           Query::EventTime() <= Query::Double(end_time);
       TraceEventVector create_events;
       int num_creates = static_cast<int>(analyzer_->FindEvents(find_this_create,
                                                                &create_events));
       EXPECT_EQ(expected_creates, num_creates);
 
       // For debugging failures, print out the width and height of each resize:
       LOG(INFO) <<
           base::StringPrintf(
               "%d (resize offset %d): IOSurface width %d -> %d; Creates %d "
               "Expected %d", offset_i, offsets[offset_i],
               old_width, new_width, num_creates, expected_creates);
     }
   }
+  LOG(INFO) << "finished test";
 }
 #endif
 
 }  // namespace