Prelaunch GPU process after 10 seconds....

chrome/renderer/render_thread.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 "chrome/renderer/render_thread.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
+#include "base/field_trial.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/nullable_string16.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/stats_table.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/thread_local.h"
 #include "base/utf_string_conversions.h"
@@ skipping 86 matching lines @@
 using WebKit::WebString;
 using WebKit::WebStorageEventDispatcher;
 using WebKit::WebView;
 
 namespace {
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
 static const double kInitialIdleHandlerDelayS = 1.0 /* seconds */;
 static const double kInitialExtensionIdleHandlerDelayS = 5.0 /* seconds */;
 static const int64 kMaxExtensionIdleHandlerDelayS = 5*60 /* seconds */;
 
+static const int kPrelauchGpuPercentage = 5;
+static const int kPrelauchGpuProcessDelayMS = 10000;
+
 // Keep the global RenderThread in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 static base::LazyInstance<base::ThreadLocalPointer<RenderThread> > lazy_tls(
     base::LINKER_INITIALIZED);
 
 #if defined(OS_POSIX)
 class SuicideOnChannelErrorFilter : public IPC::ChannelProxy::MessageFilter {
   void OnChannelError() {
     // On POSIX, at least, one can install an unload handler which loops
     // forever and leave behind a renderer process which eats 100% CPU forever.
@@ skipping 132 matching lines @@
   cookie_message_filter_ = new CookieMessageFilter();
   AddFilter(cookie_message_filter_.get());
 
 #if defined(OS_POSIX)
   suicide_on_channel_error_filter_ = new SuicideOnChannelErrorFilter;
   AddFilter(suicide_on_channel_error_filter_.get());
 #endif
 
   // Establish a channel to the GPU process asynchronously if requested. If the
   // channel is established in time, EstablishGpuChannelSync will not block when
-  // it is later called.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kPrelaunchGpuProcess)) {
-    EstablishGpuChannel();
+  // it is later called. Delays by a fixed period of time to avoid loading the
+  // GPU immediately in an attempt to not slow startup time.
+  scoped_refptr<FieldTrial> prelaunch_trial(
+      new FieldTrial("PrelaunchGpuProcessExperiment", 100));
+  int prelaunch_group = prelaunch_trial->AppendGroup("prelaunch_gpu_process",
+                                                     kPrelauchGpuPercentage);
+  if (prelaunch_group == prelaunch_trial->group() ||
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kPrelaunchGpuProcess)) {
+    message_loop()->PostDelayedTask(FROM_HERE,
+                                    task_factory_->NewRunnableMethod(
+                                        &RenderThread::EstablishGpuChannel),
+                                    kPrelauchGpuProcessDelayMS);
   }
 }
 
 RenderThread::~RenderThread() {
   // Wait for all databases to be closed.
   if (web_database_observer_impl_.get())
     web_database_observer_impl_->WaitForAllDatabasesToClose();
 
   // Shutdown in reverse of the initialization order.
   RemoveFilter(db_message_filter_.get());
@@ skipping 782 matching lines @@
 }
 
 std::string RenderThread::GetExtensionIdByBrowseExtent(const GURL& url) {
   for (size_t i = 0; i < extension_extents_.size(); ++i) {
     if (extension_extents_[i].browse_extent.ContainsURL(url))
       return extension_extents_[i].extension_id;
   }
 
   return std::string();
 }