STH Set: Delay loading until after start-up.

chrome/browser/component_updater/sth_set_component_installer.cc

 // Copyright 2016 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/component_updater/sth_set_component_installer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/net/sth_distributor_provider.h"
+#include "chrome/common/chrome_features.h"
 #include "components/component_updater/component_updater_paths.h"
-#include "components/safe_json/safe_json_parser.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "net/cert/ct_log_response_parser.h"
 #include "net/cert/signed_tree_head.h"
 #include "net/cert/sth_distributor.h"
 #include "net/cert/sth_observer.h"
 
 using component_updater::ComponentUpdateService;
 
 namespace {
@@ skipping 13 matching lines @@
 // The extension id is: ojjgnpkioondelmggbekfhllhdaimnho
 const uint8_t kPublicKeySHA256[32] = {
     0xe9, 0x96, 0xdf, 0xa8, 0xee, 0xd3, 0x4b, 0xc6, 0x61, 0x4a, 0x57,
     0xbb, 0x73, 0x08, 0xcd, 0x7e, 0x51, 0x9b, 0xcc, 0x69, 0x08, 0x41,
     0xe1, 0x96, 0x9f, 0x7c, 0xb1, 0x73, 0xef, 0x16, 0x80, 0x0a};
 
 const char kSTHSetFetcherManifestName[] = "Signed Tree Heads";
 
 STHSetComponentInstallerTraits::STHSetComponentInstallerTraits(
     net::ct::STHObserver* sth_observer)
-    : sth_observer_(sth_observer) {}
+    : sth_observer_(sth_observer), weak_ptr_factory_(this) {}
 
 STHSetComponentInstallerTraits::~STHSetComponentInstallerTraits() {}
 
 bool STHSetComponentInstallerTraits::CanAutoUpdate() const {
   return true;
 }
 
 // Public data is delivered via this component, no need for encryption.
 bool STHSetComponentInstallerTraits::RequiresNetworkEncryption() const {
   return false;
 }
 
 bool STHSetComponentInstallerTraits::OnCustomInstall(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) {
   return true;  // Nothing custom here.
 }
 
 void STHSetComponentInstallerTraits::ComponentReady(
     const base::Version& version,
     const base::FilePath& install_dir,
     std::unique_ptr<base::DictionaryValue> manifest) {
-  if (!content::BrowserThread::PostBlockingPoolTask(
-          FROM_HERE,
-          base::Bind(&STHSetComponentInstallerTraits::LoadSTHsFromDisk,
-                     base::Unretained(this), GetInstalledPath(install_dir),
-                     version))) {
-    NOTREACHED();
+  const base::Closure load_sths_closure = base::Bind(
+      &STHSetComponentInstallerTraits::LoadSTHsFromDisk,
+      weak_ptr_factory_.GetWeakPtr(), GetInstalledPath(install_dir), version);
+
+  if (variations::GetVariationParamValueByFeature(features::kSTHSetComponent,
+                                                  "delayed_load") != "no") {
+    DVLOG(1) << "Delaying STHSet load until after start-up.";
+    content::BrowserThread::PostAfterStartupTask(
+        FROM_HERE, content::BrowserThread::GetBlockingPool(),
+        load_sths_closure);
+  } else {
+    DVLOG(1) << "Loading STHSet during start-up.";
+    content::BrowserThread::PostBlockingPoolTask(FROM_HERE, load_sths_closure);
   }
 }
 
 // Called during startup and installation before ComponentReady().
 bool STHSetComponentInstallerTraits::VerifyInstallation(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) const {
   return base::PathExists(GetInstalledPath(install_dir));
 }
 
@@ skipping 45 matching lines @@
     const std::string log_id(reinterpret_cast<const char*>(&decoding_output[0]),
                              decoding_output.size());
 
     std::string json_sth;
     if (!base::ReadFileToString(sth_file_path, &json_sth)) {
       DVLOG(1) << "Failed reading from " << sth_file_path.value();
       continue;
     }
 
     DVLOG(1) << "STH: Successfully read: " << json_sth;
-    safe_json::SafeJsonParser::Parse(
-        json_sth,
-        base::Bind(&STHSetComponentInstallerTraits::OnJsonParseSuccess,
-                   base::Unretained(this), log_id),
-        base::Bind(&STHSetComponentInstallerTraits::OnJsonParseError,
-                   base::Unretained(this), log_id));
+
+    int error_code = 0;

[Alexei Svitkine (slow), 2016/07/13 19:25:01]

Can you keep the old behavior based on variation params so we can see the effect
experimentally? Otherwise, it will be hard to judge the effect of this.

[Eran Messeri, 2016/07/14 10:01:03]

Done.

+    std::string error_message;
+    std::unique_ptr<base::Value> parsed_json =
+        base::JSONReader::ReadAndReturnError(json_sth, base::JSON_PARSE_RFC,
+                                             &error_code, &error_message);
+
+    if (error_code == base::JSONReader::JSON_NO_ERROR) {
+      OnJsonParseSuccess(log_id, std::move(parsed_json));
+    } else {
+      OnJsonParseError(log_id, error_message);
+    }
   }
 }
 
 void STHSetComponentInstallerTraits::OnJsonParseSuccess(
     const std::string& log_id,
     std::unique_ptr<base::Value> parsed_json) {
   net::ct::SignedTreeHead signed_tree_head;
   DVLOG(1) << "STH parsing success for log: "
            << base::HexEncode(log_id.data(), log_id.length());
   if (!net::ct::FillSignedTreeHead(*(parsed_json.get()), &signed_tree_head)) {
@@ skipping 27 matching lines @@
 
   std::unique_ptr<ComponentInstallerTraits> traits(
       new STHSetComponentInstallerTraits(distributor));
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer =
       new DefaultComponentInstaller(std::move(traits));
   installer->Register(cus, base::Closure());
 }
 
 }  // namespace component_updater