Allow efficient WebURL -> GURL conversions

url/gurl.h

 // Copyright 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 URL_GURL_H_
 #define URL_GURL_H_
 
 #include <iosfwd>
 #include <string>
 
@@ skipping 23 matching lines @@
   // version to assume the query parameter encoding should be the same as the
   // input encoding.
   explicit GURL(const std::string& url_string /*, output_param_encoding*/);
   explicit GURL(const base::string16& url_string /*, output_param_encoding*/);
 
   // Constructor for URLs that have already been parsed and canonicalized. This
   // is used for conversions from KURL, for example. The caller must supply all
   // information associated with the URL, which must be correct and consistent.
   GURL(const char* canonical_spec, size_t canonical_spec_len,
        const url_parse::Parsed& parsed, bool is_valid);
+  // Notice that we take the canonical_spec by value so that we can convert
+  // from WebURL without copying the string. When we call this constructor
+  // we pass in a temporary std::string, which lets the compiler skip the
+  // copy and just move the std::string into the function argument. In the
+  // implementation, we use swap to move the data into the GURL itself,
+  // which means we end up with zero copies.
+  GURL(std::string canonical_spec,
+       const url_parse::Parsed& parsed, bool is_valid);
 
   ~GURL();
 
   GURL& operator=(const GURL& other);
 
   // Returns true when this object represents a valid parsed URL. When not
   // valid, other functions will still succeed, but you will not get canonical
   // data out in the format you may be expecting. Instead, we keep something
   // "reasonable looking" so that the user can see how it's busted if
   // displayed to them.
@@ skipping 274 matching lines @@
   // This function may be called from any thread.
   static const GURL& EmptyGURL();
 
   // Returns the inner URL of a nested URL [currently only non-null for
   // filesystem: URLs].
   const GURL* inner_url() const {
     return inner_url_;
   }
 
  private:
+  void InitializeFromCanonicalSpec();
+
   // Returns the substring of the input identified by the given component.
   std::string ComponentString(const url_parse::Component& comp) const {
     if (comp.len <= 0)
       return std::string();
     return std::string(spec_, comp.begin, comp.len);
   }
 
   // The actual text of the URL, in canonical ASCII form.
   std::string spec_;
 
   // Set when the given URL is valid. Otherwise, we may still have a spec and
   // components, but they may not identify valid resources (for example, an
   // invalid port number, invalid characters in the scheme, etc.).
   bool is_valid_;
 
   // Identified components of the canonical spec.
   url_parse::Parsed parsed_;
 
   // Used for nested schemes [currently only filesystem:].
   GURL* inner_url_;
 
   // TODO bug 684583: Add encoding for query params.
 };
 
 // Stream operator so GURL can be used in assertion statements.
 URL_EXPORT std::ostream& operator<<(std::ostream& out, const GURL& url);
 
 #endif  // URL_GURL_H_