Rename Origin.unique() to opaque().

url/origin.cc

 // Copyright 2015 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.
 
 #include "url/origin.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/logging.h"
@@ skipping 16 matching lines @@
     DCHECK(url.scheme() == kHttpsScheme);
     replacements.SetSchemeStr(kHttpsSuboriginScheme);
   }
   std::string new_host = suborigin + "." + url.host();
   replacements.SetHostStr(new_host);
   return url.ReplaceComponents(replacements);
 }
 
 }  // namespace
 
-Origin::Origin() : unique_(true), suborigin_(std::string()) {}
+Origin::Origin() : opaque_(true), suborigin_(std::string()) {}
 
-Origin::Origin(const GURL& url) : unique_(true), suborigin_(std::string()) {
+Origin::Origin(const GURL& url) : opaque_(true), suborigin_(std::string()) {
   if (!url.is_valid() || (!url.IsStandard() && !url.SchemeIsBlob()))
     return;
 
   if (url.SchemeIsFileSystem()) {
     tuple_ = SchemeHostPort(*url.inner_url());
   } else if (url.SchemeIsBlob()) {
     // If we're dealing with a 'blob:' URL, https://url.spec.whatwg.org/#origin
     // defines the origin as the origin of the URL which results from parsing
     // the "path", which boils down to everything after the scheme. GURL's
     // 'GetContent()' gives us exactly that.
@@ skipping 20 matching lines @@
 
     bool invalid_suborigin = no_dot || suborigin_end == 0;
     if (invalid_suborigin || tuple_.IsInvalid())
       return;
 
     suborigin_ = host.substr(0, suborigin_end);
   } else {
     tuple_ = SchemeHostPort(url);
   }
 
-  unique_ = tuple_.IsInvalid();
+  opaque_ = tuple_.IsInvalid();
 }
 
 Origin::Origin(base::StringPiece scheme,
                base::StringPiece host,
                uint16_t port,
                base::StringPiece suborigin,
                SchemeHostPort::ConstructPolicy policy)
     : tuple_(scheme.as_string(), host.as_string(), port, policy) {
-  unique_ = tuple_.IsInvalid();
+  opaque_ = tuple_.IsInvalid();
   suborigin_ = suborigin.as_string();
 }
 
 Origin::Origin(std::string scheme,
                std::string host,
                uint16_t port,
                std::string suborigin,
                SchemeHostPort::ConstructPolicy policy)
     : tuple_(std::move(scheme), std::move(host), port, policy) {
-  unique_ = tuple_.IsInvalid();
+  opaque_ = tuple_.IsInvalid();
   suborigin_ = std::move(suborigin);
 }
 
 Origin::~Origin() {
 }
 
 // static
 Origin Origin::UnsafelyCreateOriginWithoutNormalization(
     base::StringPiece scheme,
     base::StringPiece host,
     uint16_t port,
     base::StringPiece suborigin) {
   return Origin(scheme, host, port, suborigin,
                 SchemeHostPort::CHECK_CANONICALIZATION);
 }
 
 Origin Origin::CreateFromNormalizedTupleWithSuborigin(
     std::string scheme,
     std::string host,
     uint16_t port,
     std::string suborigin) {
   return Origin(std::move(scheme), std::move(host), port, std::move(suborigin),
                 SchemeHostPort::ALREADY_CANONICALIZED);
 }
 
 std::string Origin::Serialize() const {
-  if (unique())
+  if (opaque())
     return "null";
 
   if (scheme() == kFileScheme)
     return "file://";
 
   if (!suborigin_.empty()) {
     GURL url_with_suborigin = AddSuboriginToUrl(tuple_.GetURL(), suborigin_);
     return SchemeHostPort(url_with_suborigin).Serialize();
   }
 
   return tuple_.Serialize();
 }
 
 Origin Origin::GetPhysicalOrigin() const {
   if (suborigin_.empty())
     return *this;
 
   return Origin(tuple_.GetURL());
 }
 
 GURL Origin::GetURL() const {
-  if (unique())
+  if (opaque())
     return GURL();
 
   if (scheme() == kFileScheme)
     return GURL("file:///");
 
   GURL tuple_url(tuple_.GetURL());
 
   if (!suborigin_.empty())
     return AddSuboriginToUrl(tuple_url, suborigin_);
 
   return tuple_url;
 }
 
 bool Origin::IsSameOriginWith(const Origin& other) const {
-  if (unique_ || other.unique_)
+  if (opaque_ || other.opaque_)
     return false;
 
   return tuple_.Equals(other.tuple_) && suborigin_ == other.suborigin_;
 }
 
 bool Origin::IsSamePhysicalOriginWith(const Origin& other) const {
   return GetPhysicalOrigin().IsSameOriginWith(other.GetPhysicalOrigin());
 }
 
 bool Origin::DomainIs(base::StringPiece lower_ascii_domain) const {
-  return !unique_ && url::DomainIs(tuple_.host(), lower_ascii_domain);
+  return !opaque_ && url::DomainIs(tuple_.host(), lower_ascii_domain);
 }
 
 bool Origin::operator<(const Origin& other) const {
   return tuple_ < other.tuple_ ||
          (tuple_.Equals(other.tuple_) && suborigin_ < other.suborigin_);
 }
 
 std::ostream& operator<<(std::ostream& out, const url::Origin& origin) {
   return out << origin.Serialize();
 }
 
 bool IsSameOriginWith(const GURL& a, const GURL& b) {
   return Origin(a).IsSameOriginWith(Origin(b));
 }
 
 bool IsSamePhysicalOriginWith(const GURL& a, const GURL& b) {
   return Origin(a).IsSamePhysicalOriginWith(Origin(b));
 }
 
 }  // namespace url