Use AuthCredentials throughout the network stack instead of username/password.

net/socket_stream/socket_stream_unittest.cc

 // Copyright (c) 2011 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/socket_stream/socket_stream.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 126 matching lines @@
     if (!on_error_.is_null())
       on_error_.Run(&events_.back());
     if (callback_)
       callback_->Run(error);
   }
 
   void DoClose(SocketStreamEvent* event) {
     event->socket->Close();
   }
   void DoRestartWithAuth(SocketStreamEvent* event) {
-    VLOG(1) << "RestartWithAuth username=" << username_
-            << " password=" << password_;
-    event->socket->RestartWithAuth(username_, password_);
+    VLOG(1) << "RestartWithAuth username=" << credentials_.username()

[asanka, 2011/10/27 20:01:20]

DVLOG

[cbentzel, 2011/10/28 02:18:40]

Not in this CL. 

+            << " password=" << credentials_.password();
+    event->socket->RestartWithAuth(credentials_);
   }
-  void SetAuthInfo(const string16& username,
-                   const string16& password) {
-    username_ = username;
-    password_ = password;
+  void SetAuthInfo(const net::AuthCredentials& credentials) {
+    credentials_ = credentials;
   }
   void CompleteConnection(int result) {
     connection_callback_->Run(result);
   }
 
   const std::vector<SocketStreamEvent>& GetSeenEvents() const {
     return events_;
   }
 
  private:
   std::vector<SocketStreamEvent> events_;
   base::Callback<int(SocketStreamEvent*)> on_start_open_connection_;
   base::Callback<void(SocketStreamEvent*)> on_connected_;
   base::Callback<void(SocketStreamEvent*)> on_sent_data_;
   base::Callback<void(SocketStreamEvent*)> on_received_data_;
   base::Callback<void(SocketStreamEvent*)> on_close_;
   base::Callback<void(SocketStreamEvent*)> on_auth_required_;
   base::Callback<void(SocketStreamEvent*)> on_error_;
   net::OldCompletionCallback* callback_;
   net::OldCompletionCallback* connection_callback_;
-
-  string16 username_;
-  string16 password_;
+  net::AuthCredentials credentials_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketStreamEventRecorder);
 };
 
 namespace net {
 
 class SocketStreamTest : public PlatformTest {
  public:
   virtual ~SocketStreamTest() {}
   virtual void SetUp() {
@@ skipping 179 matching lines @@
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   mock_socket_factory.AddSocketDataProvider(&data2);
 
   TestOldCompletionCallback callback;
 
   scoped_ptr<SocketStreamEventRecorder> delegate(
       new SocketStreamEventRecorder(&callback));
   delegate->SetOnConnected(base::Bind(&SocketStreamEventRecorder::DoClose,
                                       base::Unretained(delegate.get())));
-  delegate->SetAuthInfo(ASCIIToUTF16("foo"), ASCIIToUTF16("bar"));
+  delegate->SetAuthInfo(net::AuthCredentials(ASCIIToUTF16("foo"),
+                                             ASCIIToUTF16("bar")));
   delegate->SetOnAuthRequired(base::Bind(
       &SocketStreamEventRecorder::DoRestartWithAuth,
       base::Unretained(delegate.get())));
 
   scoped_refptr<SocketStream> socket_stream(
       new SocketStream(GURL("ws://example.com/demo"), delegate.get()));
 
   socket_stream->set_context(new TestURLRequestContext("myproxy:70"));
   MockHostResolver host_resolver;
   socket_stream->SetHostResolver(&host_resolver);
@@ skipping 246 matching lines @@
 
   EXPECT_EQ(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
             events[0].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_CONNECTED, events[1].event_type);
   EXPECT_EQ(SocketStreamEvent::EVENT_ERROR, events[2].event_type);
   EXPECT_EQ(net::ERR_ABORTED, events[2].error_code);
   EXPECT_EQ(SocketStreamEvent::EVENT_CLOSE, events[3].event_type);
 }
 
 }  // namespace net