Reporting: Remove persistence for now.

net/reporting/reporting_persister.cc

 // Copyright 2017 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/reporting/reporting_persister.h"
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "net/reporting/reporting_cache.h"
 #include "net/reporting/reporting_client.h"
 #include "net/reporting/reporting_context.h"
-#include "net/reporting/reporting_delegate.h"
 #include "net/reporting/reporting_observer.h"
 #include "net/reporting/reporting_policy.h"
 #include "net/reporting/reporting_report.h"
 
 namespace net {
 namespace {
 
 std::unique_ptr<base::Value> SerializeOrigin(const url::Origin& origin) {
   auto serialized = base::MakeUnique<base::DictionaryValue>();
 
@@ skipping 24 matching lines @@
 
   std::string suborigin;
   if (!serialized.GetString("suborigin", &suborigin))
     return false;
 
   *origin_out = url::Origin::CreateFromNormalizedTupleWithSuborigin(
       scheme, host, port, suborigin);
   return true;
 }
 
-class ReportingPersisterImpl : public ReportingPersister,
-                               public ReportingObserver {
+class ReportingPersisterImpl : public ReportingPersister {
  public:
-  ReportingPersisterImpl(ReportingContext* context)
-      : context_(context), timer_(base::MakeUnique<base::OneShotTimer>()) {}
+  ReportingPersisterImpl(ReportingContext* context) : context_(context) {}
 
   // ReportingPersister implementation:
 
-  ~ReportingPersisterImpl() override {
-    DCHECK(context_->initialized());
-    context_->RemoveObserver(this);
-  }
-
-  void Initialize() override {
-    std::unique_ptr<const base::Value> persisted_data =
-        context_->delegate()->GetPersistedData();
-    if (persisted_data)
-      Deserialize(*persisted_data);
-    context_->AddObserver(this);
-  }
-
-  void SetTimerForTesting(std::unique_ptr<base::Timer> timer) override {
-    DCHECK(!context_->initialized());
-    timer_ = std::move(timer);
-  }
-
-  // ReportingObserver implementation:
-
-  void OnCacheUpdated() override {
-    DCHECK(context_->initialized());
-    if (!timer_->IsRunning())
-      StartTimer();
-  }
+  ~ReportingPersisterImpl() override {}
 
  private:
-  void StartTimer() {
-    timer_->Start(
-        FROM_HERE, context_->policy().persistence_interval,
-        base::Bind(&ReportingPersisterImpl::Persist, base::Unretained(this)));
-  }
-
-  void Persist() { delegate()->PersistData(Serialize()); }
-
   std::string SerializeTicks(base::TimeTicks time_ticks) {
     base::Time time = time_ticks - tick_clock()->NowTicks() + clock()->Now();
     return base::Int64ToString(time.ToInternalValue());
   }
 
   bool DeserializeTicks(const std::string& serialized,
                         base::TimeTicks* time_ticks_out) {
     int64_t internal;
     if (!base::StringToInt64(serialized, &internal))
       return false;
@@ skipping 212 matching lines @@
       if (!serialized->GetList("clients", &clients))
         return false;
       if (!DeserializeClients(*clients))
         return false;
     }
 
     return true;
   }
 
   const ReportingPolicy& policy() { return context_->policy(); }
-  ReportingDelegate* delegate() { return context_->delegate(); }
   base::Clock* clock() { return context_->clock(); }
   base::TickClock* tick_clock() { return context_->tick_clock(); }
   ReportingCache* cache() { return context_->cache(); }
 
   ReportingContext* context_;
-  std::unique_ptr<base::Timer> timer_;
 };
 
 }  // namespace
 
 // static
 std::unique_ptr<ReportingPersister> ReportingPersister::Create(
     ReportingContext* context) {
   return base::MakeUnique<ReportingPersisterImpl>(context);
 }
 
 ReportingPersister::~ReportingPersister() {}
 
 }  // namespace net