Remove the word "factory" from WebSocketChannel

net/websockets/websocket_channel_test.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_channel.h"
 
 #include <string.h>
 
 #include <iostream>
 #include <string>
@@ skipping 631 matching lines @@
                    const CompletionCallback& callback));
   MOCK_METHOD2(WriteFrames,
                int(ScopedVector<WebSocketFrame>* frames,
                    const CompletionCallback& callback));
   MOCK_METHOD0(Close, void());
   MOCK_CONST_METHOD0(GetSubProtocol, std::string());
   MOCK_CONST_METHOD0(GetExtensions, std::string());
   MOCK_METHOD0(AsWebSocketStream, WebSocketStream*());
 };
 
-struct ArgumentCopyingWebSocketStreamFactory {
-  scoped_ptr<WebSocketStreamRequest> Factory(
+struct ArgumentCopyingWebSocketStreamCreator {
+  scoped_ptr<WebSocketStreamRequest> Create(
       const GURL& socket_url,
       const std::vector<std::string>& requested_subprotocols,
       const GURL& origin,
       URLRequestContext* url_request_context,
       const BoundNetLog& net_log,
       scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
     this->socket_url = socket_url;
     this->requested_subprotocols = requested_subprotocols;
     this->origin = origin;
     this->url_request_context = url_request_context;
@@ skipping 24 matching lines @@
 
   // Creates a new WebSocketChannel and connects it, using the settings stored
   // in |connect_data_|.
   void CreateChannelAndConnect() {
     channel_.reset(new WebSocketChannel(CreateEventInterface(),
                                         &connect_data_.url_request_context));
     channel_->SendAddChannelRequestForTesting(
         connect_data_.socket_url,
         connect_data_.requested_subprotocols,
         connect_data_.origin,
-        base::Bind(&ArgumentCopyingWebSocketStreamFactory::Factory,
-                   base::Unretained(&connect_data_.factory)));
+        base::Bind(&ArgumentCopyingWebSocketStreamCreator::Create,
+                   base::Unretained(&connect_data_.creator)));
   }
 
   // Same as CreateChannelAndConnect(), but calls the on_success callback as
   // well. This method is virtual so that subclasses can also set the stream.
   virtual void CreateChannelAndConnectSuccessfully() {
     CreateChannelAndConnect();
-    connect_data_.factory.connect_delegate->OnSuccess(stream_.Pass());
+    connect_data_.creator.connect_delegate->OnSuccess(stream_.Pass());
   }
 
   // Returns a WebSocketEventInterface to be passed to the WebSocketChannel.
   // This implementation returns a newly-created fake. Subclasses may return a
   // mock instead.
   virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() {
     return scoped_ptr<WebSocketEventInterface>(new FakeWebSocketEventInterface);
   }
 
   // This method serves no other purpose than to provide a nice syntax for
@@ skipping 13 matching lines @@
     // URLRequestContext object.
     URLRequestContext url_request_context;
 
     // URL to (pretend to) connect to.
     GURL socket_url;
     // Requested protocols for the request.
     std::vector<std::string> requested_subprotocols;
     // Origin of the request
     GURL origin;
 
-    // A fake WebSocketStreamFactory that just records its arguments.
-    ArgumentCopyingWebSocketStreamFactory factory;
+    // A fake WebSocketStreamCreator that just records its arguments.
+    ArgumentCopyingWebSocketStreamCreator creator;
   };
   ConnectData connect_data_;
 
   // The channel we are testing. Not initialised until SetChannel() is called.
   scoped_ptr<WebSocketChannel> channel_;
 
   // A mock or fake stream for tests that need one.
   scoped_ptr<WebSocketStream> stream_;
 };
 
@@ skipping 116 matching lines @@
       : mock_stream_(new StrictMock<MockWebSocketStream>) {}
 
   virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
     set_stream(mock_stream_.Pass());
     WebSocketChannelTest::CreateChannelAndConnectSuccessfully();
   }
 
   scoped_ptr<MockWebSocketStream> mock_stream_;
 };
 
-// Simple test that everything that should be passed to the factory function is
-// passed to the factory function.
-TEST_F(WebSocketChannelTest, EverythingIsPassedToTheFactoryFunction) {
+// Simple test that everything that should be passed to the creator function is
+// passed to the creator function.
+TEST_F(WebSocketChannelTest, EverythingIsPassedToTheCreatorFunction) {
   connect_data_.socket_url = GURL("ws://example.com/test");
   connect_data_.origin = GURL("http://example.com/test");
   connect_data_.requested_subprotocols.push_back("Sinbad");
 
   CreateChannelAndConnect();
 
-  const ArgumentCopyingWebSocketStreamFactory& actual = connect_data_.factory;
+  const ArgumentCopyingWebSocketStreamCreator& actual = connect_data_.creator;
 
   EXPECT_EQ(&connect_data_.url_request_context, actual.url_request_context);
 
   EXPECT_EQ(connect_data_.socket_url, actual.socket_url);
   EXPECT_EQ(connect_data_.requested_subprotocols,
             actual.requested_subprotocols);
   EXPECT_EQ(connect_data_.origin, actual.origin);
 }
 
 // Any WebSocketEventInterface methods can delete the WebSocketChannel and
 // return CHANNEL_DELETED. The WebSocketChannelDeletingTests are intended to
 // verify that there are no use-after-free bugs when this happens. Problems will
 // probably only be found when running under Address Sanitizer or a similar
 // tool.
 TEST_F(WebSocketChannelDeletingTest, OnAddChannelResponseFail) {
   CreateChannelAndConnect();
   EXPECT_TRUE(channel_);
-  connect_data_.factory.connect_delegate->OnFailure(
+  connect_data_.creator.connect_delegate->OnFailure(
       kWebSocketErrorNoStatusReceived);
   EXPECT_EQ(NULL, channel_.get());
 }
 
 // Deletion is possible (due to IPC failure) even if the connect succeeds.
 TEST_F(WebSocketChannelDeletingTest, OnAddChannelResponseSuccess) {
   CreateChannelAndConnectSuccessfully();
   EXPECT_EQ(NULL, channel_.get());
 }
 
@@ skipping 175 matching lines @@
 
 TEST_F(WebSocketChannelEventInterfaceTest, ConnectSuccessReported) {
   // false means success.
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, ""));
   // OnFlowControl is always called immediately after connect to provide initial
   // quota to the renderer.
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
 
   CreateChannelAndConnect();
 
-  connect_data_.factory.connect_delegate->OnSuccess(stream_.Pass());
+  connect_data_.creator.connect_delegate->OnSuccess(stream_.Pass());
 }
 
 TEST_F(WebSocketChannelEventInterfaceTest, ConnectFailureReported) {
   // true means failure.
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(true, ""));
 
   CreateChannelAndConnect();
 
-  connect_data_.factory.connect_delegate->OnFailure(
+  connect_data_.creator.connect_delegate->OnFailure(
       kWebSocketErrorNoStatusReceived);
 }
 
 TEST_F(WebSocketChannelEventInterfaceTest, ProtocolPassed) {
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, "Bob"));
   EXPECT_CALL(*event_interface_, OnFlowControl(_));
 
   CreateChannelAndConnect();
 
-  connect_data_.factory.connect_delegate->OnSuccess(
+  connect_data_.creator.connect_delegate->OnSuccess(
       scoped_ptr<WebSocketStream>(new FakeWebSocketStream("Bob", "")));
 }
 
 // The first frames from the server can arrive together with the handshake, in
 // which case they will be available as soon as ReadFrames() is called the first
 // time.
 TEST_F(WebSocketChannelEventInterfaceTest, DataLeftFromHandshake) {
   scoped_ptr<ReadableFakeWebSocketStream> stream(
       new ReadableFakeWebSocketStream);
   static const InitFrame frames[] = {
@@ skipping 993 matching lines @@
 // Set the closing handshake timeout to a very tiny value before connecting.
 class WebSocketChannelStreamTimeoutTest : public WebSocketChannelStreamTest {
  protected:
   WebSocketChannelStreamTimeoutTest() {}
 
   virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
     set_stream(mock_stream_.Pass());
     CreateChannelAndConnect();
     channel_->SetClosingHandshakeTimeoutForTesting(
         TimeDelta::FromMilliseconds(kVeryTinyTimeoutMillis));
-    connect_data_.factory.connect_delegate->OnSuccess(stream_.Pass());
+    connect_data_.creator.connect_delegate->OnSuccess(stream_.Pass());
   }
 };
 
 // In this case the server initiates the closing handshake with a Close
 // message. WebSocketChannel responds with a matching Close message, and waits
 // for the server to close the TCP/IP connection. The server never closes the
 // connection, so the closing handshake times out and WebSocketChannel closes
 // the connection itself.
 TEST_F(WebSocketChannelStreamTimeoutTest, ServerInitiatedCloseTimesOut) {
   static const InitFrame frames[] = {
@@ skipping 88 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 }  // namespace
 }  // namespace net