Initial implementation for sharing field trial state (win)

base/metrics/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 "base/metrics/field_trial.h"
 
 #include <algorithm>
 #include <utility>
 
+#include "base/base_switches.h"
 #include "base/build_time.h"
+#include "base/command_line.h"
+#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace base {
 
 namespace {
 
 // Define a separator character to use when creating a persistent form of an
 // instance.  This is intended for use as a command line argument, passed to a
 // second process to mimic our state (i.e., provide the same group name).
 const char kPersistentStringSeparator = '/';  // Currently a slash.
 
 // Define a marker character to be used as a prefix to a trial name on the
 // command line which forces its activation.
 const char kActivationMarker = '*';
 
+// Use shared memory to communicate field trial (experiment) state.
+const base::Feature kShareFieldTrialStateViaSharedMemory{
+    "ShareFieldTrialStateViaSharedMemory", base::FEATURE_DISABLED_BY_DEFAULT};

[Alexei Svitkine (slow), 2016/10/06 21:39:28]

Nit: How about "UseSharedMemoryForFieldTrials" - a bit shorter?

[lawrencewu, 2016/10/07 15:07:21]

Done.

+
 // Created a time value based on |year|, |month| and |day_of_month| parameters.
 Time CreateTimeFromParams(int year, int month, int day_of_month) {
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
   DCHECK_LT(day_of_month, 32);
 
   Time::Exploded exploded;
   exploded.year = year;
@@ skipping 510 matching lines @@
       // Call |group()| to mark the trial as "used" and notify observers, if
       // any. This is useful to ensure that field trials created in child
       // processes are properly reported in crash reports.
       trial->group();
     }
   }
   return true;
 }
 
 // static
+void FieldTrialList::CreateTrialsFromCommandLine(
+    const base::CommandLine& cmd_line,
+    const char* field_trial_handle_switch) {
+  DCHECK(global_);
+
+#if defined(OS_WIN)
+  if (cmd_line.HasSwitch(field_trial_handle_switch)) {
+    std::string arg = cmd_line.GetSwitchValueASCII(field_trial_handle_switch);
+    size_t token = arg.find(",");
+    int field_trial_handle = std::stoi(arg.substr(0, token));
+    int field_trial_length = std::stoi(arg.substr(token + 1, arg.length()));

[Alexei Svitkine (slow), 2016/10/06 21:39:28]

Do you need to do any kind of error handling here?

[lawrencewu, 2016/10/07 15:07:21]

I thought about it, and I think it is unnecessary -- if the command line has the
handle switch, then it must be the case that it was added by
CopyFieldTrialStateToFlags(), so there will be a ',' separated by two integers
in the flag param.

+
+    HANDLE handle = reinterpret_cast<HANDLE>(field_trial_handle);
+    base::SharedMemoryHandle shm_handle =
+        base::SharedMemoryHandle(handle, base::GetCurrentProcId());
+
+    base::SharedMemory shared_memory(shm_handle, false);

[Alexei Svitkine (slow), 2016/10/06 21:39:28]

Add a comment that this will be deleted when this goes out of scope but that's
OK because we need it only for the duration of the CreateTrialsFromString() call
currently.

[lawrencewu, 2016/10/07 15:07:21]

Done.

+    shared_memory.Map(field_trial_length);
+
+    char* field_trial_state = static_cast<char*>(shared_memory.memory());
+    bool result = FieldTrialList::CreateTrialsFromString(
+        std::string(field_trial_state), std::set<std::string>());
+    DCHECK(result);
+    return;
+  }
+#endif
+
+  if (cmd_line.HasSwitch(switches::kForceFieldTrials)) {
+    bool result = FieldTrialList::CreateTrialsFromString(
+        cmd_line.GetSwitchValueASCII(switches::kForceFieldTrials),
+        std::set<std::string>());
+    DCHECK(result);
+  }
+}
+
+// static
+std::unique_ptr<base::SharedMemory> FieldTrialList::CopyFieldTrialStateToFlags(
+    const char* field_trial_handle_switch,
+    base::CommandLine* cmd_line) {
+  std::string field_trial_states;
+  base::FieldTrialList::AllStatesToString(&field_trial_states);
+  if (!field_trial_states.empty()) {
+    // Use shared memory to pass the state if the feature is enabled, otherwise
+    // fallback to passing it via the command line as a string.
+    if (base::FeatureList::IsEnabled(kShareFieldTrialStateViaSharedMemory)) {
+#if defined(OS_WIN)

[Alexei Svitkine (slow), 2016/10/06 21:39:28]

Put the whole if under ifdef and remove the else - just have it follow the block
- so that on non-Windows it simply doesn't check the feature and executes the
--force-fieldtrials code path.

[lawrencewu, 2016/10/07 15:07:21]

Done.

+      std::unique_ptr<base::SharedMemory> shm(new base::SharedMemory());
+      size_t length = field_trial_states.size() + 1;
+      shm->CreateAndMapAnonymous(length);
+      memcpy(shm->memory(), field_trial_states.c_str(), length);

[Alexei Svitkine (slow), 2016/10/06 21:39:28]

Is it guaranteed to be null terminated? If not, please do it explicitly.

[lawrencewu, 2016/10/07 15:07:21]

c_str() is guaranteed to be null terminated: http://stackoverflow.com/a/12697815

+
+      // HANDLE is just typedef'd to void *
+      auto uintptr_handle =
+          reinterpret_cast<std::uintptr_t>(shm->handle().GetHandle());
+      std::string field_trial_handle =
+          std::to_string(uintptr_handle) + "," + std::to_string(length);
+
+      cmd_line->AppendSwitchASCII(field_trial_handle_switch,
+                                  field_trial_handle);
+      return shm;
+#else
+      return std::unique_ptr<base::SharedMemory>(nullptr);
+#endif
+    } else {
+      cmd_line->AppendSwitchASCII(switches::kForceFieldTrials,
+                                  field_trial_states);
+    }
+  }
+  return std::unique_ptr<base::SharedMemory>(nullptr);
+}
+
+// static
 FieldTrial* FieldTrialList::CreateFieldTrial(
     const std::string& name,
     const std::string& group_name) {
   DCHECK(global_);
   DCHECK_GE(name.size(), 0u);
   DCHECK_GE(group_name.size(), 0u);
   if (name.empty() || group_name.empty() || !global_)
     return NULL;
 
   FieldTrial* field_trial = FieldTrialList::Find(name);
@@ skipping 79 matching lines @@
     return;
   }
   AutoLock auto_lock(global_->lock_);
   CHECK(!global_->PreLockedFind(trial->trial_name())) << trial->trial_name();
   trial->AddRef();
   trial->SetTrialRegistered();
   global_->registered_[trial->trial_name()] = trial;
 }
 
 }  // namespace base