Extensions: Clarify ManifestHandler interface expectations.

extensions/common/manifest_handler.h

 // Copyright (c) 2013 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.
 
 #ifndef EXTENSIONS_COMMON_MANIFEST_HANDLER_H_
 #define EXTENSIONS_COMMON_MANIFEST_HANDLER_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 11 matching lines @@
 // An interface for clients that recognize and parse keys in extension
 // manifests.
 class ManifestHandler {
  public:
   ManifestHandler();
   virtual ~ManifestHandler();
 
   // Attempts to parse the extension's manifest.
   // Returns true on success or false on failure; if false, |error| will
   // be set to a failure message.
+  // This does not perform any IO operations.

[lazyboy, 2017/04/26 22:53:03]

Thinking about it, this doesn't seem that helpful, b/c: 1) by default we assume
we're not doing IO if not explicitly specified. 2) we're not ensuring the fact
in code (opposed to ValidateExtension, where we assert it).
You can remove this but feel free to keep it if you feel necessary.

[karandeepb, 2017/04/26 22:57:38]

We were doing IO for Validate as in the example I pointed out.

. 2) we're not ensuring the fact
I think this is helpful for those implementing a ManifestHandler. That's why I
wanted it to be a guidance -> "This should not perform any IO operations". 

   virtual bool Parse(Extension* extension, base::string16* error) = 0;
 
   // Validate that files associated with this manifest key exist.
   // Validation takes place after parsing. May also append a series of
   // warning messages to |warnings|.
+  // This may perform IO operations.
   //
   // Otherwise, returns false, and a description of the error is
   // returned in |error|.
   // TODO(yoz): Change error to base::string16. See crbug.com/71980.
   virtual bool Validate(const Extension* extension,
                         std::string* error,
                         std::vector<InstallWarning>* warnings) const;
 
   // If false (the default), only parse the manifest if a registered
   // key is present in the manifest. If true, always attempt to parse
@@ skipping 35 matching lines @@
   // Calling FinalizeRegistration indicates that there are no more
   // manifest handlers to be registered.
   static void FinalizeRegistration();
 
   static bool IsRegistrationFinalized();
 
   // Call Parse on all registered manifest handlers that should parse
   // this extension.
   static bool ParseExtension(Extension* extension, base::string16* error);
 
-  // Call Validate on all registered manifest handlers for this extension.
+  // Call Validate on all registered manifest handlers for this extension. This
+  // may perform IO operations.
   static bool ValidateExtension(const Extension* extension,
                                 std::string* error,
                                 std::vector<InstallWarning>* warnings);
 
   // Calls |CreatePermission| on the manifest handler for |key|. Returns |NULL|
   // if there is no manifest handler for |key| or if the manifest handler for
   // |key| does not support custom permissions.
   static ManifestPermission* CreatePermission(const std::string& key);
 
   // Calls |CreateInitialRequiredPermission| on all registered manifest handlers
@@ skipping 61 matching lines @@
   // The priority for each manifest handler. Handlers with lower priority
   // values are evaluated first.
   ManifestHandlerPriorityMap priority_map_;
 
   bool is_finalized_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_MANIFEST_HANDLER_H_