Reland 72704 - Defered collect DirectX diagnostics until they are needed for about:gpu.

This is because collecting the stats often crashes.

Added a guard to prevent the collection of diagnostics on multiple threads simultaneously.

Renamed GPUInfo::Progress to GPUInfo::Level.

TEST=try, about:gpu does not cause concurrent diagnostics collection
BUG=none

Review URL: http://codereview.chromium.org/6364013

Review URL: http://codereview.chromium.org/6341011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@72731 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 47 insertions, 18 deletions

diff --git a/chrome/common/gpu_info.cc b/chrome/common/gpu_info.cc
index 5a88e34..8b47973 100644
--- a/chrome/common/gpu_info.cc
+++ b/chrome/common/gpu_info.cc
@@ -5,7 +5,7 @@
 #include "chrome/common/gpu_info.h"
 
 GPUInfo::GPUInfo()
-    : progress_(kUninitialized),
+    : level_(kUninitialized),
       vendor_id_(0),
       device_id_(0),
       driver_vendor_(""),
@@ -20,8 +20,8 @@ GPUInfo::GPUInfo()
       can_lose_context_(false) {
 }
 
-GPUInfo::Progress GPUInfo::progress() const {
-  return progress_;
+GPUInfo::Level GPUInfo::level() const {
+  return level_;
 }
 
 base::TimeDelta GPUInfo::initialization_time() const {
@@ -76,8 +76,8 @@ bool GPUInfo::can_lose_context() const {
   return can_lose_context_;
 }
 
-void GPUInfo::SetProgress(Progress progress) {
-  progress_ = progress;
+void GPUInfo::SetLevel(Level level) {
+  level_ = level;
 }
 
 void GPUInfo::SetInitializationTime(
diff --git a/chrome/common/gpu_info.h b/chrome/common/gpu_info.h
index 95c2237..3989c7a 100644
--- a/chrome/common/gpu_info.h
+++ b/chrome/common/gpu_info.h
@@ -22,15 +22,16 @@ class GPUInfo {
   GPUInfo();
   ~GPUInfo() {}
 
-  enum Progress {
+  enum Level {
     kUninitialized,
     kPartial,
+    kCompleting,
     kComplete,
   };
 
   // Returns whether this GPUInfo has been partially or fully initialized with
   // information.
-  Progress progress() const;
+  Level level() const;
 
   // The amount of time taken to get from the process starting to the message
   // loop being pumped.
@@ -87,7 +88,7 @@ class GPUInfo {
   // semantics are available.
   bool can_lose_context() const;
 
-  void SetProgress(Progress progress);
+  void SetLevel(Level level);
 
   void SetInitializationTime(const base::TimeDelta& initialization_time);
 
@@ -119,7 +120,7 @@ class GPUInfo {
 #endif
 
  private:
-  Progress progress_;
+  Level level_;
   base::TimeDelta initialization_time_;
   uint32 vendor_id_;
   uint32 device_id_;
diff --git a/chrome/common/gpu_info_unittest.cc b/chrome/common/gpu_info_unittest.cc
index 57227e8..34630e8 100644
--- a/chrome/common/gpu_info_unittest.cc
+++ b/chrome/common/gpu_info_unittest.cc
@@ -8,7 +8,7 @@
 // Test that an empty GPUInfo has valid members
 TEST(GPUInfoBasicTest, EmptyGPUInfo) {
   GPUInfo gpu_info;
-  EXPECT_EQ(gpu_info.progress(), GPUInfo::kUninitialized);
+  EXPECT_EQ(gpu_info.level(), GPUInfo::kUninitialized);
   EXPECT_EQ(gpu_info.initialization_time().ToInternalValue(), 0);
   EXPECT_EQ(gpu_info.vendor_id(), 0u);
   EXPECT_EQ(gpu_info.device_id(), 0u);
diff --git a/chrome/common/gpu_messages.cc b/chrome/common/gpu_messages.cc
index 7f1f5c0..65a39d4 100644
--- a/chrome/common/gpu_messages.cc
+++ b/chrome/common/gpu_messages.cc
@@ -128,7 +128,7 @@ void ParamTraits<GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params> ::Log(
 #endif  // if defined(OS_MACOSX)
 
 void ParamTraits<GPUInfo> ::Write(Message* m, const param_type& p) {
-  WriteParam(m, static_cast<int32>(p.progress()));
+  WriteParam(m, static_cast<int32>(p.level()));
   WriteParam(m, p.initialization_time());
   WriteParam(m, p.vendor_id());
   WriteParam(m, p.device_id());
@@ -149,7 +149,7 @@ void ParamTraits<GPUInfo> ::Write(Message* m, const param_type& p) {
 }
 
 bool ParamTraits<GPUInfo> ::Read(const Message* m, void** iter, param_type* p) {
-  int32 progress;
+  int32 level;
   base::TimeDelta initialization_time;
   uint32 vendor_id;
   uint32 device_id;
@@ -163,7 +163,7 @@ bool ParamTraits<GPUInfo> ::Read(const Message* m, void** iter, param_type* p) {
   std::string gl_renderer;
   std::string gl_extensions;
   bool can_lose_context;
-  bool ret = ReadParam(m, iter, &progress);
+  bool ret = ReadParam(m, iter, &level);
   ret = ret && ReadParam(m, iter, &initialization_time);
   ret = ret && ReadParam(m, iter, &vendor_id);
   ret = ret && ReadParam(m, iter, &device_id);
@@ -177,7 +177,7 @@ bool ParamTraits<GPUInfo> ::Read(const Message* m, void** iter, param_type* p) {
   ret = ret && ReadParam(m, iter, &gl_renderer);
   ret = ret && ReadParam(m, iter, &gl_extensions);
   ret = ret && ReadParam(m, iter, &can_lose_context);
-  p->SetProgress(static_cast<GPUInfo::Progress>(progress));
+  p->SetLevel(static_cast<GPUInfo::Level>(level));
   if (!ret)
     return false;
 
@@ -205,7 +205,7 @@ bool ParamTraits<GPUInfo> ::Read(const Message* m, void** iter, param_type* p) {
 
 void ParamTraits<GPUInfo> ::Log(const param_type& p, std::string* l) {
   l->append(base::StringPrintf("<GPUInfo> %d %d %x %x %s %s %x %x %x %d",
-                               p.progress(),
+                               p.level(),
                                static_cast<int32>(
                                    p.initialization_time().InMilliseconds()),
                                p.vendor_id(),
@@ -218,6 +218,24 @@ void ParamTraits<GPUInfo> ::Log(const param_type& p, std::string* l) {
                                p.can_lose_context()));
 }
 
+
+void ParamTraits<GPUInfo::Level> ::Write(Message* m, const param_type& p) {
+  WriteParam(m, static_cast<int32>(p));
+}
+
+bool ParamTraits<GPUInfo::Level> ::Read(const Message* m,
+                                    void** iter,
+                                    param_type* p) {
+  int32 level;
+  bool ret = ReadParam(m, iter, &level);
+  *p = static_cast<GPUInfo::Level>(level);
+  return ret;
+}
+
+void ParamTraits<GPUInfo::Level> ::Log(const param_type& p, std::string* l) {
+  LogParam(static_cast<int32>(p), l);
+}
+
 void ParamTraits<DxDiagNode> ::Write(Message* m, const param_type& p) {
   WriteParam(m, p.values);
   WriteParam(m, p.children);
diff --git a/chrome/common/gpu_messages_internal.h b/chrome/common/gpu_messages_internal.h
index 22da39a..6a488c3 100644
--- a/chrome/common/gpu_messages_internal.h
+++ b/chrome/common/gpu_messages_internal.h
@@ -6,6 +6,7 @@
 #include <string>
 
 #include "base/shared_memory.h"
+#include "chrome/common/gpu_info.h"
 #include "chrome/common/gpu_video_common.h"
 #include "ipc/ipc_message_macros.h"
 
@@ -55,7 +56,8 @@ IPC_MESSAGE_CONTROL0(GpuMsg_Synchronize)
 
 // Tells the GPU process to create a context for collecting graphics card
 // information.
-IPC_MESSAGE_CONTROL0(GpuMsg_CollectGraphicsInfo)
+IPC_MESSAGE_CONTROL1(GpuMsg_CollectGraphicsInfo,
+                     GPUInfo::Level /* level */)
 
 #if defined(OS_MACOSX)
 // Tells the GPU process that the browser process handled the swap
diff --git a/chrome/common/gpu_messages_unittest.cc b/chrome/common/gpu_messages_unittest.cc
index b3f2c34..4e2da79 100644
--- a/chrome/common/gpu_messages_unittest.cc
+++ b/chrome/common/gpu_messages_unittest.cc
@@ -13,7 +13,7 @@
 TEST(GPUIPCMessageTest, GPUInfo) {
   GPUInfo input;
   // Test variables taken from HP Z600 Workstation
-  input.SetProgress(GPUInfo::kPartial);
+  input.SetLevel(GPUInfo::kPartial);
   input.SetInitializationTime(base::TimeDelta::FromMilliseconds(100));
   input.SetVideoCardInfo(0x10de, 0x0658);
   input.SetDriverInfo("NVIDIA", "195.36.24");
@@ -31,7 +31,7 @@ TEST(GPUIPCMessageTest, GPUInfo) {
   GPUInfo output;
   void* iter = NULL;
   EXPECT_TRUE(IPC::ReadParam(&msg, &iter, &output));
-  EXPECT_EQ(input.progress(), output.progress());
+  EXPECT_EQ(input.level(), output.level());
   EXPECT_EQ(input.initialization_time().InMilliseconds(),
             output.initialization_time().InMilliseconds());
   EXPECT_EQ(input.vendor_id(), output.vendor_id());
diff --git a/chrome/common/gpu_param_traits.h b/chrome/common/gpu_param_traits.h
index 3ebaca0..4f13ab9 100644
--- a/chrome/common/gpu_param_traits.h
+++ b/chrome/common/gpu_param_traits.h
@@ -72,6 +72,14 @@ struct ParamTraits<GPUInfo> {
 };
 
 template <>
+struct ParamTraits<GPUInfo::Level> {
+  typedef GPUInfo::Level param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
+};
+
+template <>
 struct ParamTraits<DxDiagNode> {
   typedef DxDiagNode param_type;
   static void Write(Message* m, const param_type& p);