Add suborigins to WebSecurityOrigin

third_party/WebKit/Source/platform/exported/WebSecurityOrigin.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 30 matching lines @@
 class WebSecurityOriginPrivate : public SecurityOrigin {};
 
 WebSecurityOrigin WebSecurityOrigin::createFromString(const WebString& origin) {
   return WebSecurityOrigin(SecurityOrigin::createFromString(origin));
 }
 
 WebSecurityOrigin WebSecurityOrigin::create(const WebURL& url) {
   return WebSecurityOrigin(SecurityOrigin::create(url));
 }
 
-WebSecurityOrigin WebSecurityOrigin::createFromTuple(const WebString& protocol,
-                                                     const WebString& host,
-                                                     int port) {
-  return WebSecurityOrigin(SecurityOrigin::create(protocol, host, port));
+WebSecurityOrigin WebSecurityOrigin::createFromTupleWithSuborigin(
+    const WebString& protocol,
+    const WebString& host,
+    int port,
+    const WebString& suborigin) {
+  return WebSecurityOrigin(
+      SecurityOrigin::create(protocol, host, port, suborigin));
 }
 
 WebSecurityOrigin WebSecurityOrigin::createUnique() {
   return WebSecurityOrigin(SecurityOrigin::createUnique());
 }
 
 void WebSecurityOrigin::reset() {
   assign(0);
 }
 
 void WebSecurityOrigin::assign(const WebSecurityOrigin& other) {
   WebSecurityOriginPrivate* p =
       const_cast<WebSecurityOriginPrivate*>(other.m_private);
   if (p)
     p->ref();
   assign(p);
 }
 
 WebString WebSecurityOrigin::protocol() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->protocol();
 }
 
 WebString WebSecurityOrigin::host() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->host();
 }
 
 unsigned short WebSecurityOrigin::port() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->port();
 }
 
 unsigned short WebSecurityOrigin::effectivePort() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->effectivePort();
 }
 
+WebString WebSecurityOrigin::suborigin() const {
+  DCHECK(m_private);
+  return m_private->hasSuborigin() ? m_private->suborigin()->name() : "";
+}
+
 bool WebSecurityOrigin::isUnique() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->isUnique();
 }
 
 bool WebSecurityOrigin::canAccess(const WebSecurityOrigin& other) const {
-  ASSERT(m_private);
-  ASSERT(other.m_private);
+  DCHECK(m_private);
+  DCHECK(other.m_private);
   return m_private->canAccess(other.m_private);
 }
 
 bool WebSecurityOrigin::canRequest(const WebURL& url) const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->canRequest(url);
 }
 
 bool WebSecurityOrigin::isPotentiallyTrustworthy() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->isPotentiallyTrustworthy();
 }
 
 WebString WebSecurityOrigin::toString() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->toString();
 }
 
 bool WebSecurityOrigin::canAccessPasswordManager() const {
-  ASSERT(m_private);
+  DCHECK(m_private);
   return m_private->canAccessPasswordManager();
 }
 
 WebSecurityOrigin::WebSecurityOrigin(WTF::PassRefPtr<SecurityOrigin> origin)
     : m_private(static_cast<WebSecurityOriginPrivate*>(origin.leakRef())) {}
 
 WebSecurityOrigin& WebSecurityOrigin::operator=(
     WTF::PassRefPtr<SecurityOrigin> origin) {
   assign(static_cast<WebSecurityOriginPrivate*>(origin.leakRef()));
   return *this;
@@ skipping 13 matching lines @@
   if (m_private)
     m_private->deref();
   m_private = p;
 }
 
 void WebSecurityOrigin::grantLoadLocalResources() const {
   get()->grantLoadLocalResources();
 }
 
 }  // namespace blink