Remove content dependency from TransportSecurityPersister.

chrome/browser/net/transport_security_persister.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 "chrome/browser/net/transport_security_persister.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
-#include "base/path_service.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/sequenced_task_runner.h"
+#include "base/task_runner_util.h"
 #include "base/values.h"
-#include "chrome/common/chrome_paths.h"
-#include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/transport_security_state.h"
 
-using content::BrowserThread;
 using net::HashValue;
 using net::HashValueTag;
 using net::HashValueVector;
 using net::TransportSecurityState;
 
 namespace {
 
 ListValue* SPKIHashesToListValue(const HashValueVector& hashes) {
   ListValue* pins = new ListValue;
   for (size_t i = 0; i != hashes.size(); i++)
@@ skipping 41 matching lines @@
 const char kDynamicSPKIHashesExpiry[] = "dynamic_spki_hashes_expiry";
 const char kStaticSPKIHashes[] = "static_spki_hashes";
 const char kPreloadedSPKIHashes[] = "preloaded_spki_hashes";
 const char kDynamicSPKIHashes[] = "dynamic_spki_hashes";
 const char kForceHTTPS[] = "force-https";
 const char kStrict[] = "strict";
 const char kDefault[] = "default";
 const char kPinningOnly[] = "pinning-only";
 const char kCreated[] = "created";
 
+std::string LoadState(const base::FilePath& path) {
+  std::string result;
+  if (!base::ReadFileToString(path, &result)) {
+    return "";
+  }
+  return result;
+}
+
 }  // namespace
 
-class TransportSecurityPersister::Loader {
- public:
-  Loader(const base::WeakPtr<TransportSecurityPersister>& persister,
-         const base::FilePath& path)
-      : persister_(persister),
-        path_(path),
-        state_valid_(false) {
-  }
-
-  void Load() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    state_valid_ = base::ReadFileToString(path_, &state_);
-  }
-
-  void CompleteLoad() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-    // Make sure we're deleted.
-    scoped_ptr<Loader> deleter(this);
-
-    if (!persister_.get() || !state_valid_)
-      return;
-    persister_->CompleteLoad(state_);
-  }
-
- private:
-  base::WeakPtr<TransportSecurityPersister> persister_;
-
-  base::FilePath path_;
-
-  std::string state_;
-  bool state_valid_;
-
-  DISALLOW_COPY_AND_ASSIGN(Loader);
-};
-
 TransportSecurityPersister::TransportSecurityPersister(
     TransportSecurityState* state,
     const base::FilePath& profile_path,
+    base::SequencedTaskRunner* background_runner,
     bool readonly)
     : transport_security_state_(state),
-      writer_(profile_path.AppendASCII("TransportSecurity"),
-              BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
-                  .get()),
+      writer_(profile_path.AppendASCII("TransportSecurity"), background_runner),
+      foreground_runner_(base::MessageLoop::current()->message_loop_proxy()),
+      background_runner_(background_runner),
       readonly_(readonly),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
   transport_security_state_->SetDelegate(this);
 
-  Loader* loader = new Loader(weak_ptr_factory_.GetWeakPtr(), writer_.path());
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&Loader::Load, base::Unretained(loader)),
-      base::Bind(&Loader::CompleteLoad, base::Unretained(loader)));
+  base::PostTaskAndReplyWithResult(
+      background_runner_,
+      FROM_HERE,
+      base::Bind(&::LoadState, writer_.path()),
+      base::Bind(&TransportSecurityPersister::CompleteLoad,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 TransportSecurityPersister::~TransportSecurityPersister() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
 
   if (writer_.HasPendingWrite())
     writer_.DoScheduledWrite();
 
   transport_security_state_->SetDelegate(NULL);
 }
 
 void TransportSecurityPersister::StateIsDirty(
     TransportSecurityState* state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
   DCHECK_EQ(transport_security_state_, state);
 
   if (!readonly_)
     writer_.ScheduleWrite(this);
 }
 
 bool TransportSecurityPersister::SerializeData(std::string* output) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
 
   DictionaryValue toplevel;
   base::Time now = base::Time::Now();
   TransportSecurityState::Iterator state(*transport_security_state_);
   for (; state.HasNext(); state.Advance()) {
     const std::string& hostname = state.hostname();
     const TransportSecurityState::DomainState& domain_state =
         state.domain_state();
 
     DictionaryValue* serialized = new DictionaryValue;
@@ skipping 31 matching lines @@
   }
 
   base::JSONWriter::WriteWithOptions(&toplevel,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      output);
   return true;
 }
 
 bool TransportSecurityPersister::LoadEntries(const std::string& serialized,
                                              bool* dirty) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
 
   transport_security_state_->ClearDynamicData();
   return Deserialize(serialized, dirty, transport_security_state_);
 }
 
 // static
 bool TransportSecurityPersister::Deserialize(const std::string& serialized,
                                              bool* dirty,
                                              TransportSecurityState* state) {
   scoped_ptr<Value> value(base::JSONReader::Read(serialized));
@@ skipping 95 matching lines @@
     }
 
     state->AddOrUpdateEnabledHosts(hashed, domain_state);
   }
 
   *dirty = dirtied;
   return true;
 }
 
 void TransportSecurityPersister::CompleteLoad(const std::string& state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
 
   bool dirty = false;
   if (!LoadEntries(state, &dirty)) {
     LOG(ERROR) << "Failed to deserialize state: " << state;
     return;
   }
   if (dirty)
     StateIsDirty(transport_security_state_);
 }