Home | History | Annotate | Download | only in browser 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef EXTENSIONS_BROWSER_FILE_HIGHLIGHTER_H_
      6 #define EXTENSIONS_BROWSER_FILE_HIGHLIGHTER_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 
     12 namespace base {
     13 class DictionaryValue;
     14 }
     15 
     16 namespace extensions {
     17 
     18 // The FileHighlighter class is used in order to isolate and highlight a portion
     19 // of a given file (in string form). The Highlighter will split the source into
     20 // three portions: the portion before the highlighted feature, the highlighted
     21 // feature, and the portion following the highlighted feature.
     22 // The file will be parsed for highlighting upon construction of the Highlighter
     23 // object.
     24 class FileHighlighter {
     25  public:
     26   virtual ~FileHighlighter();
     27 
     28   // Get the portion of the manifest which should not be highlighted and is
     29   // before the feature.
     30   std::string GetBeforeFeature() const;
     31 
     32   // Get the feature portion of the manifest, which should be highlighted.
     33   std::string GetFeature() const;
     34 
     35   // Get the portion of the manifest which should not be highlighted and is
     36   // after the feature.
     37   std::string GetAfterFeature() const;
     38 
     39   // Populate a DictionaryValue with the highlighted portions (in UTF16) of the
     40   // source file.
     41   void SetHighlightedRegions(base::DictionaryValue* dict) const;
     42 
     43  protected:
     44   explicit FileHighlighter(const std::string& contents);
     45 
     46   // The contents of the file we are parsing.
     47   std::string contents_;
     48 
     49   // The start of the feature.
     50   size_t start_;
     51 
     52   // The end of the feature.
     53   size_t end_;
     54 
     55   DISALLOW_COPY_AND_ASSIGN(FileHighlighter);
     56 };
     57 
     58 // Use the ManifestHighlighter class to find the bounds of a feature in the
     59 // manifest.
     60 // A feature can be at any level in the hierarchy. The "start" of a feature is
     61 // the first character of the feature name, or the beginning quote of the name,
     62 // if present. The "end" of a feature is wherever the next item at the same
     63 // level starts.
     64 // For instance, the bounds for the 'permissions' feature at the top level could
     65 // be '"permissions": { "tabs", "history", "downloads" }', but the feature for
     66 // 'tabs' within 'permissions' would just be '"tabs"'.
     67 // We can't use the JSONParser to do this, because we want to display the actual
     68 // manifest, and once we parse it into Values, we lose any formatting the user
     69 // may have had.
     70 // If a feature cannot be found, the feature will have zero-length.
     71 class ManifestHighlighter : public FileHighlighter {
     72  public:
     73   ManifestHighlighter(const std::string& manifest,
     74                       const std::string& key,
     75                       const std::string& specific /* optional */);
     76   virtual ~ManifestHighlighter();
     77 
     78  private:
     79   // Called from the constructor; determine the start and end bounds of a
     80   // feature, using both the key and specific information.
     81   void Parse(const std::string& key, const std::string& specific);
     82 
     83   // Find the bounds of any feature, either a full key or a specific item within
     84   // the key. |enforce_at_top_level| means that the feature we find must be at
     85   // the same level as |start_| (i.e., ignore nested elements).
     86   // Returns true on success.
     87   bool FindBounds(const std::string& feature, bool enforce_at_top_level);
     88 
     89   // Finds the end of the feature.
     90   void FindBoundsEnd(const std::string& feature, size_t local_start);
     91 
     92   DISALLOW_COPY_AND_ASSIGN(ManifestHighlighter);
     93 };
     94 
     95 // Use the SourceHighlighter to highlight a particular line in a given source
     96 // file.
     97 class SourceHighlighter : public FileHighlighter {
     98  public:
     99   SourceHighlighter(const std::string& source, size_t line_number);
    100   virtual ~SourceHighlighter();
    101 
    102  private:
    103   // Called from the constructor; determine the bounds of the line in the source
    104   // file.
    105   void Parse(size_t line_number);
    106 
    107   DISALLOW_COPY_AND_ASSIGN(SourceHighlighter);
    108 };
    109 
    110 }  // namespace extensions
    111 
    112 #endif  // EXTENSIONS_BROWSER_FILE_HIGHLIGHTER_H_
    113