Remove some VerifiedContents methods' params that are always false.

extensions/browser/verified_contents.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 "extensions/browser/verified_contents.h"
 
 #include <stddef.h>
 
 #include "base/base64url.h"
 #include "base/files/file_util.h"
@@ skipping 72 matching lines @@
 //       "files": [
 //         {
 //           "path": "foo/bar",
 //           "root_hash": "<base64url encoded bytes>"
 //         },
 //         ...
 //       ]
 //     }
 //   ]
 // }
-bool VerifiedContents::InitFrom(const base::FilePath& path,
-                                bool ignore_invalid_signature) {
+bool VerifiedContents::InitFrom(const base::FilePath& path) {
   std::string payload;
-  if (!GetPayload(path, &payload, ignore_invalid_signature))
+  if (!GetPayload(path, &payload))
     return false;
 
   std::unique_ptr<base::Value> value(base::JSONReader::Read(payload));
   if (!value.get() || !value->IsType(Value::Type::DICTIONARY))
     return false;
   DictionaryValue* dictionary = static_cast<DictionaryValue*>(value.get());
 
   std::string item_id;
   if (!dictionary->GetString(kItemIdKey, &item_id) ||
       !crx_file::id_util::IdIsValid(item_id))
@@ skipping 116 matching lines @@
 //     }
 //   }
 // ]
 // There might be both a signature generated with a webstore private key and a
 // signature generated with the extension's private key - for now we only
 // verify the webstore one (since the id is in the payload, so we can trust
 // that it is for a given extension), but in the future we may validate using
 // the extension's key too (eg for non-webstore hosted extensions such as
 // enterprise installs).
 bool VerifiedContents::GetPayload(const base::FilePath& path,
-                                  std::string* payload,
-                                  bool ignore_invalid_signature) {
+                                  std::string* payload) {
   std::string contents;
   if (!base::ReadFileToString(path, &contents))
     return false;
   std::unique_ptr<base::Value> value(base::JSONReader::Read(contents));
   if (!value.get() || !value->IsType(Value::Type::LIST))
     return false;
   ListValue* top_list = static_cast<ListValue*>(value.get());
 
   // Find the "treehash per file" signed content, e.g.
   // [
@@ skipping 32 matching lines @@
                              base::Base64UrlDecodePolicy::IGNORE_PADDING,
                              &decoded_signature))
     return false;
 
   std::string encoded_payload;
   if (!signed_content->GetString(kPayloadKey, &encoded_payload))
     return false;
 
   valid_signature_ =
       VerifySignature(protected_value, encoded_payload, decoded_signature);
-  if (!valid_signature_ && !ignore_invalid_signature)
+  if (!valid_signature_)
     return false;
 
   if (!base::Base64UrlDecode(encoded_payload,
                              base::Base64UrlDecodePolicy::IGNORE_PADDING,
                              payload))
     return false;
 
   return true;
 }
 
@@ skipping 21 matching lines @@
       reinterpret_cast<const uint8_t*>(payload.data()), payload.size());
 
   if (!signature_verifier.VerifyFinal()) {
     VLOG(1) << "Could not verify signature - VerifyFinal failure";
     return false;
   }
   return true;
 }
 
 }  // namespace extensions