javascript_code_block.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_JAVASCRIPT_CODE_BLOCK_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_JAVASCRIPT_CODE_BLOCK_H_

#include <cstddef>

#include "base/logging.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/escaping.h"
#include "pagespeed/kernel/base/hasher.h"
#include "pagespeed/kernel/base/source_map.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/google_url.h"

namespace pagespeed { namespace js { struct JsTokenizerPatterns; } }

namespace net_instaweb {

class JavascriptLibraryIdentification;
class MessageHandler;
class Statistics;
class Variable;

class JavascriptRewriteConfig {
 public:
  static const char kBlocksMinified[];
  static const char kLibrariesIdentified[];
  static const char kMinificationFailures[];
  static const char kTotalBytesSaved[];
  static const char kTotalOriginalBytes[];
  static const char kMinifyUses[];
  static const char kNumReducingMinifications[];

  static const char kJSMinificationDisabled[];
  static const char kJSDidNotShrink[];
  static const char kJSFailedToWrite[];

  JavascriptRewriteConfig(
      Statistics* statistics, bool minify, bool use_experimental_minifier,
      const JavascriptLibraryIdentification* identification,
      const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns);

  static void InitStats(Statistics* statistics);

  bool minify() const { return minify_; }
  bool use_experimental_minifier() const { return use_experimental_minifier_; }
  const JavascriptLibraryIdentification* library_identification() const {
    return library_identification_;
  }
  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns() const {
    return js_tokenizer_patterns_;
  }

  Variable* blocks_minified() { return blocks_minified_; }
  Variable* libraries_identified() { return libraries_identified_; }
  Variable* minification_failures() { return minification_failures_; }
  Variable* total_bytes_saved() { return total_bytes_saved_; }
  Variable* total_original_bytes() { return total_original_bytes_; }
  Variable* num_uses() { return num_uses_; }
  Variable* num_reducing_uses() { return num_reducing_minifications_; }

  Variable* minification_disabled() { return minification_disabled_; }
  Variable* did_not_shrink() { return did_not_shrink_; }
  Variable* failed_to_write() { return failed_to_write_; }

 private:
  bool minify_;
  bool use_experimental_minifier_;
  const JavascriptLibraryIdentification* library_identification_;
  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns_;

  Variable* blocks_minified_;
  Variable* libraries_identified_;
  Variable* minification_failures_;
  Variable* total_bytes_saved_;
  Variable* total_original_bytes_;
  Variable* num_uses_;
  Variable* num_reducing_minifications_;

  Variable* minification_disabled_;
  Variable* did_not_shrink_;
  Variable* failed_to_write_;

  
};

class JavascriptCodeBlock {
 public:
  static const char kIntrospectionComment[];

  JavascriptCodeBlock(const StringPiece& original_code,
                      JavascriptRewriteConfig* config,
                      const StringPiece& message_id,
                      MessageHandler* handler);

  virtual ~JavascriptCodeBlock();

  bool Rewrite();

  bool successfully_rewritten() const {
    DCHECK(rewritten_);
    return successfully_rewritten_;
  }
  StringPiece rewritten_code() const {
    DCHECK(rewritten_);
    DCHECK(successfully_rewritten_);
    return rewritten_code_;
  }

  const source_map::MappingVector& SourceMappings() const {
    DCHECK(rewritten_);
    DCHECK(successfully_rewritten_);
    return source_mappings_;
  }

  void AppendSourceMapUrl(StringPiece url);

  StringPiece ComputeJavascriptLibrary() const;

  void SwapRewrittenString(GoogleString* other);

  static bool UnsafeToRename(const StringPiece& script);

  static void ToJsStringLiteral(const StringPiece& original,
                                GoogleString* escaped) {
    EscapeToJsStringLiteral(original, true , escaped);
  }

  static GoogleString JsUrlHash(const GoogleString &url, Hasher *hasher) {
    GoogleString url_hash = hasher->Hash(GoogleUrl(url).PathAndLeaf());
    size_t pos = 0;
    while ((pos = url_hash.find_first_of('-', pos)) != GoogleString::npos) {
      url_hash[pos] = '$';
    }
    return url_hash;
  }

  const GoogleString& message_id() const { return message_id_; }

 private:
  static bool IsSanitarySourceMapUrl(StringPiece url);

  bool MinifyJs(StringPiece input, GoogleString* output,
                source_map::MappingVector* source_mappings);

  JavascriptRewriteConfig* config_;
  const GoogleString message_id_; 
  const GoogleString original_code_;
  GoogleString rewritten_code_;
  source_map::MappingVector source_mappings_;

  bool rewritten_;
  bool successfully_rewritten_;

  MessageHandler* handler_;

  
};

}  

#endif