[Prerender] Get the prerender mode from Finch field trial.

chrome/browser/prerender/prerender_field_trial.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/prerender/prerender_field_trial.h"
 
 #include <string>
 
-#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/common/chrome_switches.h"
+#include "components/variations/variations_associated_data.h"
 
 namespace prerender {
 
-void ConfigurePrerender(const base::CommandLine& command_line) {
+const base::Feature kNoStatePrefetchFeature{"NoStatePrefetch",
+                                            base::FEATURE_ENABLED_BY_DEFAULT};

[pasko, 2016/12/01 16:47:58]

maybe disabled by default?

[droger, 2016/12/01 17:17:40]

No, it is enabled by default (but in "Prerender" mode).

The feature disabled means that prerender is disabled.

[pasko, 2016/12/01 17:30:44]

I think the general ideology of a Feature is to have it disabled when the
feature is in development, then enable it (via finch, then permanently), then
remove the mention of the feature potentially. So starting as enabled looks
counter-intuitive to me. Also, feature "NoStatePrefetch" to mean "Prerender"
when enabled may confuse people, no?

[droger, 2016/12/01 17:39:49]

I think it would be even more confusing, but that could work too.

In that world, we would have:

feature disabled = prerender

feature enabled with 3 modes:
- simple load
- prefetch
- disabled

Having a feature enabled with a disabled mode seems strange to me...

Or maybe we could have a feature + another separate switch to disable
everything?

[droger, 2016/12/01 17:48:27]

Also in my mind, in the long term we would not remove the feature, but keep one
feature called NoStatePrefetch that can be enabled and disabled. We would remove
the finch experiment and the parameters though.
And my code is kind of a first step towards that.

+
+void ConfigurePrerender() {
   PrerenderManager::PrerenderManagerMode mode =
       PrerenderManager::PRERENDER_MODE_ENABLED;
-  if (command_line.HasSwitch(switches::kPrerenderMode)) {
-    const std::string switch_value =
-        command_line.GetSwitchValueASCII(switches::kPrerenderMode);
-
-    if (switch_value == switches::kPrerenderModeSwitchValueDisabled) {
-      mode = PrerenderManager::PRERENDER_MODE_DISABLED;
-    } else if (switch_value == switches::kPrerenderModeSwitchValuePrefetch) {
+  if (!base::FeatureList::IsEnabled(kNoStatePrefetchFeature)) {
+    mode = PrerenderManager::PRERENDER_MODE_DISABLED;
+  } else {
+    std::string mode_value = variations::GetVariationParamValueByFeature(
+        kNoStatePrefetchFeature, "mode");
+    if (mode_value == "no_state_prefetch") {
       mode = PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH;
-    } else if (switch_value.empty() ||
-               switch_value == switches::kPrerenderModeSwitchValueEnabled) {
+    } else if (mode_value.empty() || mode_value == "prerender") {
       // The empty string means the option was provided with no value, and that
       // means enable.
       mode = PrerenderManager::PRERENDER_MODE_ENABLED;
-    } else if (switch_value == switches::kPrerenderModeSwitchValueSimpleLoad) {
+    } else if (mode_value == "simple_load") {
       mode = PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT;
     } else {
+      LOG(ERROR) << "Invalid prerender mode: " << mode_value;
+      LOG(ERROR) << "Disabling prerendering!";
       mode = PrerenderManager::PRERENDER_MODE_DISABLED;
-      LOG(ERROR) << "Invalid --prerender option received on command line: "
-                 << switch_value;
-      LOG(ERROR) << "Disabling prerendering!";
     }
   }
 
   PrerenderManager::SetMode(mode);
 }
 
 bool IsOmniboxEnabled(Profile* profile) {
   if (!profile)
     return false;
 
@@ skipping 14 matching lines @@
       return false;
 
     DCHECK_EQ(switches::kPrerenderFromOmniboxSwitchValueAuto, switch_value);
   }
 
   return (base::FieldTrialList::FindFullName("PrerenderFromOmnibox") !=
           "OmniboxPrerenderDisabled");
 }
 
 }  // namespace prerender