Add LoadState reporting to the mojo proxy resolver.

net/base/load_state_change_coalescer.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 "net/base/load_state_change_coalescer.h"
+
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
+
+namespace net {
+
+LoadStateChangeCoalescer::LoadStateChangeCoalescer(
+    const base::Callback<void(LoadState)>& callback,
+    const base::TimeDelta& timeout,
+    LoadState initial_load_state)
+    : callback_(callback),
+      timeout_(timeout),
+      committed_load_state_(initial_load_state),
+      pending_load_state_(initial_load_state) {
+}
+
+void LoadStateChangeCoalescer::LoadStateChanged(LoadState load_state) {
+  if (load_state == committed_load_state_) {
+    pending_load_state_change_.Cancel();

[eroman, 2015/03/06 05:13:01]

Personally I think a OneShotTimer would be easier to follow in this code.

[Sam McNally, 2015/03/06 09:33:02]

Done.

+    return;
+  }
+  pending_load_state_ = load_state;
+  pending_load_state_change_.Reset(base::Bind(

[eroman, 2015/03/06 05:13:01]

Won't this mean that If the load state is continuously changing, at a rate
faster than timeout_, we will never report a loadstate changed?

I think there should be a maximum reporting delay.

To be honest I don't think the LoadState timer optimization should be included
in this CL, would be easier to review it as a follow-up.

[Sam McNally, 2015/03/06 09:33:02]

If we use a maximum delay, a continuously changing load state will degenerate
into sampling with a frequency of that maximum delay, which I don't think is
more useful.
Done.

+      &LoadStateChangeCoalescer::SendLoadStateChanged, base::Unretained(this)));
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, pending_load_state_change_.callback(), timeout_);
+}
+
+LoadStateChangeCoalescer::~LoadStateChangeCoalescer() = default;
+
+void LoadStateChangeCoalescer::SendLoadStateChanged() {
+  callback_.Run(pending_load_state_);
+  pending_load_state_change_.Cancel();
+  committed_load_state_ = pending_load_state_;
+}
+
+}  // namespace net