PyAuto test for GPU memory consumption

chrome/browser/automation/testing_automation_provider.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 "chrome/browser/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 117 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
+#include "content/browser/gpu/gpu_process_host.h"
+#include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/geolocation.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 1867 matching lines @@
       &TestingAutomationProvider::KillRendererProcess;
 
   browser_handler_map_["LaunchApp"] = &TestingAutomationProvider::LaunchApp;
   browser_handler_map_["SetAppLaunchType"] =
       &TestingAutomationProvider::SetAppLaunchType;
 
   browser_handler_map_["GetV8HeapStats"] =
       &TestingAutomationProvider::GetV8HeapStats;
   browser_handler_map_["GetFPS"] =
       &TestingAutomationProvider::GetFPS;
+  browser_handler_map_["GetGpuMemStats"] =
+      &TestingAutomationProvider::GetGpuMemStats;
 
   browser_handler_map_["IsFullscreenForBrowser"] =
       &TestingAutomationProvider::IsFullscreenForBrowser;
   browser_handler_map_["IsFullscreenForTab"] =
       &TestingAutomationProvider::IsFullscreenForTab;
   browser_handler_map_["IsMouseLocked"] =
       &TestingAutomationProvider::IsMouseLocked;
   browser_handler_map_["IsMouseLockPermissionRequested"] =
       &TestingAutomationProvider::IsMouseLockPermissionRequested;
   browser_handler_map_["IsFullscreenPermissionRequested"] =
@@ skipping 3836 matching lines @@
   int routing_id = render_view->GetRoutingID();
 
   // This observer will delete itself.
   new FPSObserver(
       this, reply_message,
       base::GetProcId(render_view->GetProcess()->GetHandle()),
       routing_id);
   render_view->Send(new ChromeViewMsg_GetFPS(routing_id));
 }
 
+// Class to use for the callback from GpuProcessHost when memory
+// stats are received
+class GpuProcessHostOnMemStatsCallback {
+ public:
+  GpuProcessHostOnMemStatsCallback(
+    TestingAutomationProvider* provider,
+    IPC::Message* reply_message) :
+    provider_(provider),
+    reply_message_(reply_message) {
+  }
+  ~GpuProcessHostOnMemStatsCallback() {
+  }
+  void OnMemStatsCallback(const content::GpuMemStats& mem_stats) {
+    DictionaryValue dict;
+    dict.SetBoolean("gpu_active", true);
+    dict.SetInteger("gpu_memory_bytes_total", mem_stats.total_bytes);
+    dict.SetInteger("gpu_memory_bytes_used",
+                    mem_stats.currently_allocated_bytes);
+    AutomationJSONReply(provider_, reply_message_).SendSuccess(&dict);
+    delete this;
+  }
+
+ private:
+  TestingAutomationProvider* provider_;
+  IPC::Message* reply_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuProcessHostOnMemStatsCallback);
+};
+
+void TestingAutomationProvider::GetGpuMemStats(
+  Browser* browser,
+  DictionaryValue* args,
+  IPC::Message* reply_message) {
+  // Execute on the IO thread, since this needs to talk to the GPU process
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&TestingAutomationProvider::GetGpuMemStats, this, browser,
+                   args, reply_message));
+    return;
+  }
+
+  GpuProcessHost* host = GpuProcessHost::Get(
+    GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
+    content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH);
+  if (host) {
+    // This object will delete itself upon receiving the OnMemStats callback
+    // from the GpuProcessHost
+    GpuProcessHostOnMemStatsCallback* callback =
+      new GpuProcessHostOnMemStatsCallback(this, reply_message);
+    host->SetOnMemStatsCallback(
+        base::Bind(&GpuProcessHostOnMemStatsCallback::OnMemStatsCallback,
+                   base::Unretained(callback)));
+    host->Send(new GpuMsg_GetMemStats());
+  } else {
+    DictionaryValue dict;
+    dict.SetBoolean("gpu_active", false);
+    AutomationJSONReply(this, reply_message).SendSuccess(&dict);
+  }
+}
+
 void TestingAutomationProvider::IsFullscreenForBrowser(Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   DictionaryValue dict;
   dict.SetBoolean("result",
                   browser->fullscreen_controller()->IsFullscreenForBrowser());
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsFullscreenForTab(Browser* browser,
@@ skipping 879 matching lines @@
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   if (chrome::GetActiveWebContents(browser) != tab)
     chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, tab), true);
 }