Fix getting initially active trials with shared memory.

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"
@@ skipping 607 matching lines @@
     if (entry.activated) {
       FieldTrial::ActiveGroup group;
       group.trial_name = entry.trial_name.as_string();
       group.group_name = entry.group_name.as_string();
       active_groups->push_back(group);
     }
   }
 }
 
 // static
+void FieldTrialList::GetInitiallyActiveFieldTrials(
+    const base::CommandLine& command_line,
+    FieldTrial::ActiveGroups* active_groups) {
+  DCHECK(global_->create_trials_from_command_line_called_);

[lawrencewu, 2016/11/18 16:33:10]

This function is called or can be called before CreateTrialsFromCommandLine().
Does this have to be called after it? Getting the active groups and creating the
trials seems independent from each other.

[Alexei Svitkine (slow), 2016/11/18 16:35:47]

If it's called before it, then the field_trial_allocator_ won't be created yet.
So it needs to be called after.

I will take a look at why the order isn't what I expected.

+
+  if (!global_->field_trial_allocator_) {
+    GetActiveFieldTrialGroupsFromString(
+        command_line.GetSwitchValueASCII(switches::kForceFieldTrials),
+        active_groups);
+    return;
+  }
+
+  SharedPersistentMemoryAllocator* allocator =
+      global_->field_trial_allocator_.get();
+  PersistentMemoryAllocator::Iterator mem_iter(allocator);
+  SharedPersistentMemoryAllocator::Reference ref;
+  while ((ref = mem_iter.GetNextOfType(kFieldTrialType)) !=
+         SharedPersistentMemoryAllocator::kReferenceNull) {
+    const FieldTrialEntry* entry =
+        allocator->GetAsObject<const FieldTrialEntry>(ref, kFieldTrialType);
+
+    StringPiece trial_name;
+    StringPiece group_name;
+    if (entry->activated &&
+        entry->GetTrialAndGroupName(&trial_name, &group_name)) {
+      FieldTrial::ActiveGroup group;
+      group.trial_name = trial_name.as_string();
+      group.group_name = group_name.as_string();
+      active_groups->push_back(group);

[bcwhite, 2016/11/21 15:56:22]

push_back(std::move(group))

[Alexei Svitkine (slow), 2016/11/21 20:47:11]

Done.

+    }
+  }
+}
+
+// static
 bool FieldTrialList::CreateTrialsFromString(
     const std::string& trials_string,
     const std::set<std::string>& ignored_trial_names) {
   DCHECK(global_);
   if (trials_string.empty() || !global_)
     return true;
 
   std::vector<FieldTrial::State> entries;
   if (!ParseFieldTrialsString(trials_string, &entries))
     return false;
@@ skipping 15 matching lines @@
       trial->group();
     }
   }
   return true;
 }
 
 // static
 void FieldTrialList::CreateTrialsFromCommandLine(
     const CommandLine& cmd_line,
     const char* field_trial_handle_switch) {
-  DCHECK(global_);
+  global_->create_trials_from_command_line_called_ = true;
 
 #if defined(OS_WIN) && !defined(OS_NACL)
   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));
     size_t field_trial_length = std::stoi(arg.substr(token + 1, arg.length()));
 
     HANDLE handle = reinterpret_cast<HANDLE>(field_trial_handle);
     SharedMemoryHandle shm_handle =
@@ skipping 341 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