Introduce url::Origin to represent Web Origin.

net/websockets/websocket_stream.cc

 // 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.
 
 #include "net/websockets/websocket_stream.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_handshake_constants.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "net/websockets/websocket_handshake_stream_create_helper.h"
 #include "net/websockets/websocket_test_util.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 
 namespace net {
 namespace {
 
 class StreamRequestImpl;
 
 class Delegate : public URLRequest::Delegate {
  public:
   explicit Delegate(StreamRequestImpl* owner) : owner_(owner) {}
   virtual ~Delegate() {}
@@ skipping 110 matching lines @@
 
 void Delegate::OnReadCompleted(URLRequest* request, int bytes_read) {
   NOTREACHED();
 }
 
 // Internal implementation of CreateAndConnectStream and
 // CreateAndConnectStreamForTesting.
 scoped_ptr<WebSocketStreamRequest> CreateAndConnectStreamWithCreateHelper(
     const GURL& socket_url,
     scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
-    const GURL& origin,
+    const url::Origin& origin,
     URLRequestContext* url_request_context,
     const BoundNetLog& net_log,
     scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
   scoped_ptr<StreamRequestImpl> request(
       new StreamRequestImpl(socket_url,
                             url_request_context,
                             connect_delegate.Pass(),
                             create_helper.get()));
   HttpRequestHeaders headers;
   headers.SetHeader(websockets::kUpgrade, websockets::kWebSocketLowercase);
   headers.SetHeader(HttpRequestHeaders::kConnection, websockets::kUpgrade);
-  headers.SetHeader(HttpRequestHeaders::kOrigin, origin.spec());
+  headers.SetHeader(HttpRequestHeaders::kOrigin, origin.string());
   headers.SetHeader(websockets::kSecWebSocketVersion,
                     websockets::kSupportedVersion);
   request->url_request()->SetExtraRequestHeaders(headers);
   request->url_request()->SetUserData(
       WebSocketHandshakeStreamBase::CreateHelper::DataKey(),
       create_helper.release());
   request->url_request()->SetLoadFlags(LOAD_DISABLE_CACHE |
                                        LOAD_BYPASS_CACHE |
                                        LOAD_DO_NOT_PROMPT_FOR_LOGIN);
   request->url_request()->Start();
   return request.PassAs<WebSocketStreamRequest>();
 }
 
 }  // namespace
 
 WebSocketStreamRequest::~WebSocketStreamRequest() {}
 
 WebSocketStream::WebSocketStream() {}
 WebSocketStream::~WebSocketStream() {}
 
 WebSocketStream::ConnectDelegate::~ConnectDelegate() {}
 
 scoped_ptr<WebSocketStreamRequest> WebSocketStream::CreateAndConnectStream(
     const GURL& socket_url,
     const std::vector<std::string>& requested_subprotocols,
-    const GURL& origin,
+    const url::Origin& origin,
     URLRequestContext* url_request_context,
     const BoundNetLog& net_log,
     scoped_ptr<ConnectDelegate> connect_delegate) {
   scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper(
       new WebSocketHandshakeStreamCreateHelper(connect_delegate.get(),
                                                requested_subprotocols));
   return CreateAndConnectStreamWithCreateHelper(socket_url,
                                                 create_helper.Pass(),
                                                 origin,
                                                 url_request_context,
                                                 net_log,
                                                 connect_delegate.Pass());
 }
 
 // This is declared in websocket_test_util.h.
 scoped_ptr<WebSocketStreamRequest> CreateAndConnectStreamForTesting(
-      const GURL& socket_url,
-      scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
-      const GURL& origin,
-      URLRequestContext* url_request_context,
-      const BoundNetLog& net_log,
-      scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
+    const GURL& socket_url,
+    scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
+    const url::Origin& origin,
+    URLRequestContext* url_request_context,
+    const BoundNetLog& net_log,
+    scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
   return CreateAndConnectStreamWithCreateHelper(socket_url,
                                                 create_helper.Pass(),
                                                 origin,
                                                 url_request_context,
                                                 net_log,
                                                 connect_delegate.Pass());
 }
 
 }  // namespace net