Add move constructors and assignment operators to GURL

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 <stddef.h>
 
 #include <iosfwd>
@@ skipping 36 matching lines @@
  public:
   typedef url::StringPieceReplacements<std::string> Replacements;
   typedef url::StringPieceReplacements<base::string16> ReplacementsW;
 
   // Creates an empty, invalid URL.
   GURL();
 
   // Copy construction is relatively inexpensive, with most of the time going
   // to reallocating the string. It does not re-parse.
   GURL(const GURL& other);
+  GURL(GURL&& other);
 
   // The strings to this contructor should be UTF-8 / UTF-16.
   explicit GURL(base::StringPiece url_string);
   explicit GURL(base::StringPiece16 url_string);
 
   // 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::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 std::move to move the data into the GURL itself,
   // which means we end up with zero copies.
   GURL(std::string canonical_spec, const url::Parsed& parsed, bool is_valid);
 
   ~GURL();
 
-  GURL& operator=(GURL other);
+  GURL& operator=(const GURL& other);
+  GURL& operator=(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.
   bool is_valid() const {
     return is_valid_;
   }
 
@@ skipping 375 matching lines @@
 URL_EXPORT bool operator==(const GURL& x, const GURL& y);
 URL_EXPORT bool operator!=(const GURL& x, const GURL& y);
 
 // Equality operator for comparing raw spec_. This should be used in place of
 // url == GURL(spec) where |spec| is known (i.e. constants). This is to prevent
 // needlessly re-parsing |spec| into a temporary GURL.
 URL_EXPORT bool operator==(const GURL& x, const base::StringPiece& spec);
 URL_EXPORT bool operator!=(const GURL& x, const base::StringPiece& spec);
 
 #endif  // URL_GURL_H_