Domain Reliability: Add rudimentary WebUI page.

components/domain_reliability/context.cc

 // Copyright 2014 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/domain_reliability/context.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
@@ skipping 20 matching lines @@
 typedef BeaconDeque::const_iterator BeaconConstIterator;
 }  // namespace
 
 class DomainReliabilityContext::ResourceState {
  public:
   ResourceState(DomainReliabilityContext* context,
                 const DomainReliabilityConfig::Resource* config)
       : context(context),
         config(config),
         successful_requests(0),
-        failed_requests(0) {}
+        failed_requests(0),
+        uploading_beacons_size(0),
+        uploading_successful_requests(0),
+        uploading_failed_requests(0) {}
   ~ResourceState() {}
 
   // Serializes the resource state into a Value to be included in an upload.
   // If there is nothing to report (no beacons and all request counters are 0),
   // returns a scoped_ptr to NULL instead so the resource can be omitted.
   scoped_ptr<base::Value> ToValue(base::TimeTicks upload_time) const {
     if (beacons.empty() && successful_requests == 0 && failed_requests == 0)
       return scoped_ptr<base::Value>();
 
     ListValue* beacons_value = new ListValue();
@@ skipping 77 matching lines @@
       time_(time),
       upload_reporter_string_(upload_reporter_string),
       scheduler_(time,
                  config_->collectors.size(),
                  scheduler_params,
                  base::Bind(&DomainReliabilityContext::ScheduleUpload,
                             base::Unretained(this))),
       dispatcher_(dispatcher),
       uploader_(uploader),
       beacon_count_(0),
+      uploading_beacon_count_(0),
       weak_factory_(this) {
   InitializeResourceStates();
 }
 
 DomainReliabilityContext::~DomainReliabilityContext() {}
 
 void DomainReliabilityContext::OnBeacon(const GURL& url,
                                         const DomainReliabilityBeacon& beacon) {
   size_t index = config_->GetResourceIndexForUrl(url);
   if (index == DomainReliabilityConfig::kInvalidResourceIndex)
@@ skipping 36 matching lines @@
     state->successful_requests = 0;
     state->failed_requests = 0;
     state->uploading_beacons_size = 0;
     state->uploading_successful_requests = 0;
     state->uploading_failed_requests = 0;
   }
   beacon_count_ = 0;
   uploading_beacon_count_ = 0;
 }
 
+scoped_ptr<base::Value> DomainReliabilityContext::GetWebUIData() const {
+  base::DictionaryValue* context_value = new base::DictionaryValue();
+
+  context_value->SetString("domain", config().domain);
+  context_value->SetInteger("beacon_count", static_cast<int>(beacon_count_));
+  context_value->SetInteger("uploading_beacon_count",
+      static_cast<int>(uploading_beacon_count_));
+  context_value->Set("scheduler", scheduler_.GetWebUIData());
+
+  return scoped_ptr<base::Value>(context_value);
+}
+
 void DomainReliabilityContext::GetQueuedDataForTesting(
     size_t resource_index,
     std::vector<DomainReliabilityBeacon>* beacons_out,
     uint32* successful_requests_out,
     uint32* failed_requests_out) const {
   DCHECK_NE(DomainReliabilityConfig::kInvalidResourceIndex, resource_index);
   DCHECK_GT(states_.size(), resource_index);
   const ResourceState& state = *states_[resource_index];
   if (beacons_out)
     beacons_out->assign(state.beacons.begin(), state.beacons.end());
@@ skipping 109 matching lines @@
 
   min_resource->RemoveOldestBeacon();
   --beacon_count_;
   // If that just removed a beacon counted in uploading_beacon_count_, decrement
   // that.
   if (uploading_beacon_count_ > 0)
     --uploading_beacon_count_;
 }
 
 }  // namespace domain_reliability