Plumb experiment flags through page_load_metrics and add a new observer

components/page_load_metrics/renderer/page_timing_metrics_sender.cc

 // Copyright 2015 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 "components/page_load_metrics/renderer/page_timing_metrics_sender.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "ipc/ipc_sender.h"
 
 namespace page_load_metrics {
 
 namespace {
 const int kTimerDelayMillis = 1000;
 }  // namespace
 
 PageTimingMetricsSender::PageTimingMetricsSender(IPC::Sender* ipc_sender,
                                                  int routing_id,
                                                  scoped_ptr<base::Timer> timer)
     : ipc_sender_(ipc_sender),
       routing_id_(routing_id),
-      timer_(std::move(timer)) {}
+      timer_(std::move(timer)),
+      metadata_(PageLoadMetadata()) {}
 
 // On destruction, we want to send any data we have if we have a timer
 // currently running (and thus are talking to a browser process)
 PageTimingMetricsSender::~PageTimingMetricsSender() {
   if (timer_->IsRunning()) {
     timer_->Stop();
     SendNow();
   }
 }
 
+void PageTimingMetricsSender::DidObserveLoadingBehavior(
+    blink::WebLoadingBehaviorFlag behavior) {
+  metadata_.behavior_flags |= behavior;

[Bryan McQuade, 2016/04/11 20:18:47]

should we also start the send timer here if it's not already started? maybe we
can factor the logic for starting the timer into a helper and call it from this
method and from the end of Send(const PageLoadTiming&); otherwise, if a behavior
is observed shortly after the last timing update gets sent, we'll never get the
behavior update on the browser side.

if we do this, we might also add a check to see if the existing flag is already
set in the metadata, and return early if so, to avoid sending updates when no
new state has been observed.

[Charlie Harrison, 2016/04/12 15:18:50]

Done.

+}
+
 void PageTimingMetricsSender::Send(const PageLoadTiming& timing) {
   if (timing == last_timing_)
     return;
 
   // We want to make sure that each PageTimingMetricsSender is associated
   // with a distinct page navigation. Because we reset the object on commit,
   // we can trash last_timing_ on a provisional load before SendNow() fires.
   if (!last_timing_.navigation_start.is_null() &&
       last_timing_.navigation_start != timing.navigation_start) {
     return;

[Bryan McQuade, 2016/04/11 20:18:47]

perhaps a separate change, but i'm wondering if this early return is needed
anymore. IIRC we only dispatch timing updates for committed docs, so it seems
like it'd be an error now to ever get a mismatched nav start. perhaps in a
separate CL we could change this to assert as well?

[Charlie Harrison, 2016/04/12 15:18:50]

Can investigate this in a separate change. I think you're right though.

   }
 
   last_timing_ = timing;
 
   if (!timer_->IsRunning())
     timer_->Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(kTimerDelayMillis),
         base::Bind(&PageTimingMetricsSender::SendNow, base::Unretained(this)));
 }
 
 void PageTimingMetricsSender::SendNow() {
-  ipc_sender_->Send(
-      new PageLoadMetricsMsg_TimingUpdated(routing_id_, last_timing_));
+  ipc_sender_->Send(new PageLoadMetricsMsg_TimingUpdated(
+      routing_id_, last_timing_, metadata_));
 }
 
 }  // namespace page_load_metrics