Wait for the GPU info to be collected.

chrome/test/gpu/gpu_pixel_browsertest.cc

 // Copyright (c) 2010 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 <string>
 #include <vector>
 
 #include "app/app_switches.h"
 #include "app/gfx/gl/gl_implementation.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/gpu_process_host.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
@@ skipping 51 matching lines @@
   gfx::Point correction(desired_size.width() - container_rect.size().width(),
                         desired_size.height() - container_rect.size().height());
 
   gfx::Rect window_rect = browser->window()->GetRestoredBounds();
   gfx::Size new_size = window_rect.size();
   new_size.Enlarge(correction.x(), correction.y());
   window_rect.set_size(new_size);
   browser->window()->SetBounds(window_rect);
 }
 
+// Observes when any GPU info has been collected and quits the current message
+// loop.
+class GPUInfoCollectedObserver {
+ public:
+  explicit GPUInfoCollectedObserver(GpuProcessHostUIShim* gpu_host_shim)
+      : gpu_host_shim_(gpu_host_shim),
+        gpu_info_collected_(false) {
+    gpu_host_shim_->set_gpu_info_collected_callback(
+        NewCallback(this, &GPUInfoCollectedObserver::OnGpuInfoCollected));
+  }
+
+  void OnGpuInfoCollected() {
+    gpu_info_collected_ = true;
+    gpu_host_shim_->set_gpu_info_collected_callback(NULL);
+    MessageLoopForUI::current()->Quit();
+  }
+
+  bool gpu_info_collected() { return gpu_info_collected_; }
+
+ private:
+  GpuProcessHostUIShim* gpu_host_shim_;
+  bool gpu_info_collected_;
+};
+
+// Collects info about the GPU. Iff the info is collected, |client_info| will be
+// set and true will be returned. This info may be partial or complete. This
+// will return false if we are running in a virtualized environment.
+bool CollectGPUInfo(GPUInfo* client_info) {
+  CHECK(client_info);
+  GpuProcessHostUIShim* gpu_host_shim = GpuProcessHostUIShim::GetInstance();
+  if (!gpu_host_shim)
+    return false;
+  GPUInfo info = gpu_host_shim->gpu_info();
+  if (info.progress() == GPUInfo::kUninitialized) {
+    GPUInfoCollectedObserver observer(gpu_host_shim);
+    gpu_host_shim->CollectGraphicsInfoAsynchronously();
+    ui_test_utils::RunMessageLoop();
+    if (!observer.gpu_info_collected())
+      return false;
+    info = gpu_host_shim->gpu_info();
+  }
+  *client_info = info;
+  return true;
+}
+
 }  // namespace
 
 // Test fixture for GPU image comparison tests.
 // TODO(kkania): Document how to add to/modify these tests.
 class GpuPixelBrowserTest : public InProcessBrowserTest {
  public:
   GpuPixelBrowserTest() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) {
     // This enables DOM automation for tab contents.
@@ skipping 58 matching lines @@
 #if defined(OS_WIN)
       const char* os_label = "win";
 #elif defined(OS_MACOSX)
       const char* os_label = "mac";
 #elif defined(OS_LINUX)
       const char* os_label = "linux";
 #else
 #error "Not implemented for this platform"
 #endif
     if (using_gpu_) {
-      const GPUInfo& info = GpuProcessHostUIShim::GetInstance()->gpu_info();
-      if (info.progress() != GPUInfo::kComplete) {
+      GPUInfo info;
+      if (!CollectGPUInfo(&info)) {
         LOG(ERROR) << "Could not get gpu info";
         return false;
       }
-      img_name = StringPrintf("%s_%s_%x-%x.png",
+      img_name = base::StringPrintf("%s_%s_%04x-%04x.png",
           img_name.c_str(), os_label, info.vendor_id(), info.device_id());
     } else {
-      img_name = StringPrintf("%s_%s_mesa.png", img_name.c_str(), os_label);
+      img_name = base::StringPrintf("%s_%s_mesa.png",
+          img_name.c_str(), os_label);
     }
 
     // Read the reference image and verify the images' dimensions are equal.
     FilePath ref_img_path = reference_img_dir_.AppendASCII(img_name);
     SkBitmap ref_bmp;
     bool should_compare = true;
     if (!ReadPNGFile(ref_img_path, &ref_bmp)) {
       LOG(ERROR) << "Cannot read reference image: " << ref_img_path.value();
       should_compare = false;
     }
@@ skipping 88 matching lines @@
   ASSERT_TRUE(message_queue.WaitForMessage(NULL));
 
   SkBitmap bitmap;
   gfx::Size container_size(500, 500);
   ResizeTabContainer(browser(), container_size);
   ASSERT_TRUE(ui_test_utils::TakeRenderWidgetSnapshot(
       browser()->GetSelectedTabContents()->render_view_host(),
       container_size, &bitmap));
   ASSERT_TRUE(CompareImages(bitmap, ""));
 }