Remove Chrome Frame's delay shutdown field trial.

chrome_frame/chrome_frame_automation.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_frame/chrome_frame_automation.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/metrics/field_trial.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/client_util.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome_frame/chrome_launcher_utils.h"
 #include "chrome_frame/crash_reporting/crash_metrics.h"
 #include "chrome_frame/custom_sync_call_context.h"
 #include "chrome_frame/navigation_constraints.h"
 #include "chrome_frame/simple_resource_loader.h"
 #include "chrome_frame/utils.h"
 #include "ui/base/ui_base_switches.h"
 
 namespace {
 
 #ifdef NDEBUG
 int64 kAutomationServerReasonableLaunchDelay = 1000;  // in milliseconds
 #else
 int64 kAutomationServerReasonableLaunchDelay = 1000 * 10;
 #endif
 
-const char kChromeShutdownDelaySeconds[] = "30";
-const char kWithDelayFieldTrialName[] = "WithShutdownDelay";
-const char kNoDelayFieldTrialName[] = "NoShutdownDelay";
-
 }  // namespace
 
 class ChromeFrameAutomationProxyImpl::TabProxyNotificationMessageFilter
     : public IPC::ChannelProxy::MessageFilter {
  public:
   explicit TabProxyNotificationMessageFilter(AutomationHandleTracker* tracker)
       : tracker_(tracker) {
   }
 
   void AddTabProxy(AutomationHandle tab_proxy) {
@@ skipping 235 matching lines @@
     // In headless mode runs like reliability test runs we want full crash dumps
     // from chrome.
     if (IsHeadlessMode())
       command_line->AppendSwitch(switches::kFullMemoryCrashReport);
 
     // In accessible mode automation tests expect renderer accessibility to be
     // enabled in chrome.
     if (IsAccessibleMode())
       command_line->AppendSwitch(switches::kForceRendererAccessibility);
 
-    if (params->send_shutdown_delay_switch())
-      command_line->AppendSwitchASCII(switches::kChromeFrameShutdownDelay,
-                                      kChromeShutdownDelaySeconds);
-
     DVLOG(1) << "Profile path: " << params->profile_path().value();
     command_line->AppendSwitchPath(switches::kUserDataDir,
                                    params->profile_path());
 
     // Ensure that Chrome is running the specified version of chrome.dll.
     command_line->AppendSwitchNative(switches::kChromeVersion,
                                      GetCurrentModuleVersion());
 
     if (!params->language().empty())
       command_line->AppendSwitchNative(switches::kLang, params->language());
@@ skipping 24 matching lines @@
     // version string it reported.
     launch_result_ = proxy->WaitForAppLaunch();
     launch_stats.Dump();
 
     base::TimeDelta delta =
         base::TimeTicks::Now() - automation_server_launch_start_time_;
 
     if (launch_result_ == AUTOMATION_SUCCESS) {
       UMA_HISTOGRAM_TIMES(
           "ChromeFrame.AutomationServerLaunchSuccessTime", delta);
-      UMA_HISTOGRAM_TIMES(
-          base::FieldTrial::MakeName(
-              "ChromeFrame.AutomationServerLaunchSuccessTime",
-              "ChromeShutdownDelay"),
-          delta);
     } else {
       UMA_HISTOGRAM_TIMES(
           "ChromeFrame.AutomationServerLaunchFailedTime", delta);
-      UMA_HISTOGRAM_TIMES(
-          base::FieldTrial::MakeName(
-              "ChromeFrame.AutomationServerLaunchFailedTime",
-              "ChromeShutdownDelay"),
-          delta);
     }
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("ChromeFrame.LaunchResult",
                                 launch_result_,
                                 AUTOMATION_SUCCESS,
                                 AUTOMATION_CREATE_TAB_FAILED,
                                 AUTOMATION_CREATE_TAB_FAILED + 1);
   }
 
   TRACE_EVENT_END_ETW("chromeframe.createproxy", this, "");
@@ skipping 174 matching lines @@
       init_state_(UNINITIALIZED),
       use_chrome_network_(false),
       proxy_factory_(g_proxy_factory.Pointer()),
       handle_top_level_requests_(false),
       tab_handle_(-1),
       session_id_(-1),
       external_tab_cookie_(0),
       url_fetcher_(NULL),
       url_fetcher_flags_(PluginUrlRequestManager::NOT_THREADSAFE),
       navigate_after_initialization_(false),
-      route_all_top_level_navigations_(false),
-      send_shutdown_delay_switch_(true) {
-  InitializeFieldTrials();
+      route_all_top_level_navigations_(false) {
 }
 
 ChromeFrameAutomationClient::~ChromeFrameAutomationClient() {
   // Uninitialize must be called prior to the destructor
   DCHECK(automation_server_ == NULL);
 }
 
 bool ChromeFrameAutomationClient::Initialize(
     ChromeFrameDelegate* chrome_frame_delegate,
     ChromeFrameLaunchParams* chrome_launch_params) {
@@ skipping 118 matching lines @@
     // Important: Since we will be using the referrer_ variable from a
     // different thread, we need to force a new std::string buffer instance for
     // the referrer_ GURL variable.  Otherwise we can run into strangeness when
     // the GURL is accessed and it could result in a bad URL that can cause the
     // referrer to be dropped or something worse.
     GURL referrer_gurl(referrer.c_str());
     if (!chrome_launch_params_) {
       base::FilePath profile_path;
       chrome_launch_params_ = new ChromeFrameLaunchParams(parsed_url,
           referrer_gurl, profile_path, L"", SimpleResourceLoader::GetLanguage(),
-          false, false, route_all_top_level_navigations_,
-          send_shutdown_delay_switch_);
+          false, false, route_all_top_level_navigations_);
     } else {
       chrome_launch_params_->set_referrer(referrer_gurl);
       chrome_launch_params_->set_url(parsed_url);
     }
 
     navigate_after_initialization_ = false;
 
     if (is_initialized()) {
       BeginNavigate();
     } else {
@@ skipping 317 matching lines @@
 
   PostTask(
       FROM_HERE,
       base::Bind(
           base::IgnoreResult(
               &ChromeFrameAutomationClient::ProcessUrlRequestMessage),
           base::Unretained(this), tab, msg, true));
   return true;
 }
 
-void ChromeFrameAutomationClient::InitializeFieldTrials() {
-  static base::FieldTrial* trial = NULL;
-  if (!trial) {
-    // Do one-time initialization of the field trial here.
-    // TODO(robertshield): End the field trial before March 7th 2013.
-    scoped_refptr<base::FieldTrial> new_trial =
-        base::FieldTrialList::FactoryGetFieldTrial(
-            "ChromeShutdownDelay", 1000, kWithDelayFieldTrialName,
-            2013, 3, 7, NULL);
-
-    // Be consistent for this client. Note that this will only have an effect
-    // once the client id is persisted. See http://crbug.com/117188
-    new_trial->UseOneTimeRandomization();
-
-    new_trial->AppendGroup(kNoDelayFieldTrialName, 500);    // 50% without.
-
-    trial = new_trial.get();
-  }
-
-  // Take action depending of which group we randomly land in.
-  if (trial->group_name() == kWithDelayFieldTrialName)
-    send_shutdown_delay_switch_ = true;
-  else
-    send_shutdown_delay_switch_ = false;
-
-}
-
 // These are invoked in channel's background thread.
 // Cannot call any method of the activex here since it is a STA kind of being.
 // By default we marshal the IPC message to the main/GUI thread and from there
 // we safely invoke chrome_frame_delegate_->OnMessageReceived(msg).
 bool ChromeFrameAutomationClient::OnMessageReceived(TabProxy* tab,
                                                     const IPC::Message& msg) {
   DCHECK(tab == tab_.get());
   // Quickly process network related messages.
   if (url_fetcher_ && ProcessUrlRequestMessage(tab, msg, false))
     return true;
@@ skipping 259 matching lines @@
     const net::URLRequestStatus& status) {
   automation_server_->Send(new AutomationMsg_RequestEnd(
       tab_->handle(), request_id, status));
 }
 
 void ChromeFrameAutomationClient::OnCookiesRetrieved(bool success,
     const GURL& url, const std::string& cookie_string, int cookie_id) {
   automation_server_->Send(new AutomationMsg_GetCookiesHostResponse(
       tab_->handle(), success, url, cookie_string, cookie_id));
 }