google_url.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 PAGESPEED_KERNEL_HTTP_GOOGLE_URL_H_
#define PAGESPEED_KERNEL_HTTP_GOOGLE_URL_H_

#include <cstddef>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"


#include "third_party/chromium/src/googleurl/src/gurl.h"
#include "third_party/chromium/src/googleurl/src/url_parse.h"
#include "third_party/chromium/src/googleurl/src/url_util.h"

namespace net_instaweb {


namespace url {

using url_canon::Replacements;
using url_parse::PORT_UNSPECIFIED;
using url_parse::PORT_INVALID;
using url_parse::Component;
using url_parse::Parsed;
using url_util::Initialize;
using url_util::Shutdown;

}; 


enum UrlRelativity {
  kAbsoluteUrl,   
  kNetPath,       
  kAbsolutePath,  
  kRelativePath,  
};

class GoogleUrl {
 public:
  explicit GoogleUrl(const GoogleString& spec);
  explicit GoogleUrl(StringPiece sp);
  explicit GoogleUrl(const char* str);
  GoogleUrl(const GoogleUrl& base, const GoogleString& relative);
  GoogleUrl(const GoogleUrl& base, StringPiece relative);
  GoogleUrl(const GoogleUrl& base, const char* relative);
  GoogleUrl();

  void Swap(GoogleUrl* google_url);

  bool Reset(StringPiece new_url);
  bool Reset(const GoogleUrl& new_url);
  bool Reset(const GoogleUrl& base, const GoogleString& relative);
  bool Reset(const GoogleUrl& base, StringPiece relative);
  bool Reset(const GoogleUrl& base, const char* relative);

  void Clear();

  bool IsWebValid() const;
  bool IsWebOrDataValid() const;
  bool IsAnyValid() const;

  GoogleUrl* CopyAndAddQueryParam(StringPiece unescaped_name,
                                  StringPiece unescaped_value) const;
  GoogleUrl* CopyAndAddEscapedQueryParam(
      StringPiece escaped_name, StringPiece escaped_value) const;

  StringPiece AllExceptQuery() const;

  StringPiece AllAfterQuery() const;

  StringPiece AllExceptLeaf() const;

  StringPiece LeafWithQuery() const;

  StringPiece LeafSansQuery() const;

  StringPiece PathAndLeaf() const;

  StringPiece PathSansLeaf() const;

  StringPiece PathSansQuery() const;

  StringPiece NetPath() const;

  GoogleString ExtractFileName() const;

  StringPiece Host() const;

  StringPiece HostAndPort() const;

  StringPiece Origin() const;

  StringPiece Query() const;

  StringPiece Scheme() const;

  StringPiece Spec() const;

  StringPiece UncheckedSpec() const;

  const char* spec_c_str() const {
    return gurl_.possibly_invalid_spec().c_str();
  }

  int IntPort() const { return gurl_.IntPort(); }

  int EffectiveIntPort() const { return gurl_.EffectiveIntPort(); }

  static int DefaultPortForScheme(StringPiece scheme);

  bool is_empty() const { return gurl_.is_empty(); }
  bool has_scheme() const { return gurl_.has_scheme(); }
  bool has_path() const { return gurl_.has_path(); }
  bool has_query() const { return gurl_.has_query(); }

  bool SchemeIs(const char* lower_ascii_scheme) const {
    return gurl_.SchemeIs(lower_ascii_scheme);
  }

  bool SchemeIs(StringPiece lower_ascii_scheme) const {
    return gurl_.SchemeIs(lower_ascii_scheme.as_string().c_str());
  }

  static UrlRelativity FindRelativity(StringPiece url);

  StringPiece Relativize(UrlRelativity url_relativity,
                         const GoogleUrl& base_url) const;

  bool operator==(const GoogleUrl& other) const {
    return gurl_ == other.gurl_;
  }
  bool operator!=(const GoogleUrl& other) const {
    return gurl_ != other.gurl_;
  }

  static GoogleString UnescapeQueryParam(StringPiece escaped) {
    return UnescapeHelper(escaped, true);
  }

  static GoogleString UnescapeIgnorePlus(StringPiece escaped) {
    return UnescapeHelper(escaped, false);
  }

  static GoogleString EscapeQueryParam(StringPiece unescaped);

  static GoogleString Sanitize(StringPiece url);

  static GoogleString CanonicalizePath(StringPiece path);

 private:
  static const size_t npos;

  static const char kReservedChars[];
  static bool IsReservedChar(char c);

  explicit GoogleUrl(const GURL& gurl);
  void Init();

  static size_t LeafEndPosition(const GURL& gurl);
  static size_t LeafStartPosition(const GURL& gurl);
  static size_t PathStartPosition(const GURL& gurl);
  size_t LeafEndPosition() const;
  size_t LeafStartPosition() const;
  size_t PathStartPosition() const;
  static GoogleString UnescapeHelper(StringPiece escaped,
                                     bool convert_plus_to_space);

  inline bool ResolveHelper(const GURL& base, const std::string& path_and_leaf);

  GURL gurl_;
  bool is_web_valid_;
  bool is_web_or_data_valid_;

  
}; 

}  


#endif