Rename net::BidirectionalStream*Job to net::BidirectionalStream*Impl

net/http/http_stream_factory_impl_request.cc

 // Copyright (c) 2012 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/http/http_stream_factory_impl_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
-#include "net/http/bidirectional_stream_job.h"
+#include "net/http/bidirectional_stream_impl.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::Request::Request(
     const GURL& url,
     HttpStreamFactoryImpl* factory,
     HttpStreamRequest::Delegate* delegate,
@@ skipping 60 matching lines @@
     HttpStream* stream) {
   DCHECK(!factory_->for_websockets_);
   DCHECK_EQ(HttpStreamRequest::HTTP_STREAM, stream_type_);
   DCHECK(stream);
   DCHECK(completed_);
 
   OnJobSucceeded(job);
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
 
-void HttpStreamFactoryImpl::Request::OnBidirectionalStreamJobReady(
+void HttpStreamFactoryImpl::Request::OnBidirectionalStreamImplReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
-    BidirectionalStreamJob* stream_job) {
+    BidirectionalStreamImpl* stream_job) {
   DCHECK(!factory_->for_websockets_);
   DCHECK_EQ(HttpStreamRequest::BIDIRECTIONAL_STREAM, stream_type_);
   DCHECK(stream_job);
   DCHECK(completed_);
 
   OnJobSucceeded(job);
-  delegate_->OnBidirectionalStreamJobReady(used_ssl_config, used_proxy_info,
-                                           stream_job);
+  delegate_->OnBidirectionalStreamImplReady(used_ssl_config, used_proxy_info,
+                                            stream_job);
 }
 
 void HttpStreamFactoryImpl::Request::OnWebSocketHandshakeStreamReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     WebSocketHandshakeStreamBase* stream) {
   DCHECK(factory_->for_websockets_);
   DCHECK_EQ(HttpStreamRequest::HTTP_STREAM, stream_type_);
   DCHECK(stream);
@@ skipping 151 matching lines @@
 // TODO(jgraettinger): Currently, HttpStreamFactoryImpl::Job notifies a
 // Request that the session is ready, which in turn notifies it's delegate,
 // and then it notifies HttpStreamFactoryImpl so that /other/ requests may
 // be woken, but only if the spdy_session is still okay. This is tough to grok.
 // Instead, see if Job can notify HttpStreamFactoryImpl only, and have one
 // path for notifying any requests waiting for the session (including the
 // request which spawned it).
 void HttpStreamFactoryImpl::Request::OnNewSpdySessionReady(
     Job* job,
     scoped_ptr<HttpStream> stream,
-    scoped_ptr<BidirectionalStreamJob> bidirectional_stream_job,
+    scoped_ptr<BidirectionalStreamImpl> bidirectional_stream_impl,
     const base::WeakPtr<SpdySession>& spdy_session,
     bool direct) {
   DCHECK(job);
   DCHECK(job->using_spdy());
 
   // Note: |spdy_session| may be NULL. In that case, |delegate_| should still
   // receive |stream| so the error propagates up correctly, however there is no
   // point in broadcasting |spdy_session| to other requests.
 
   // The first case is the usual case.
@@ skipping 15 matching lines @@
 
   Complete(was_npn_negotiated, protocol_negotiated, using_spdy);
 
   // Cache this so we can still use it if the request is deleted.
   HttpStreamFactoryImpl* factory = factory_;
   if (factory->for_websockets_) {
     // TODO(ricea): Re-instate this code when WebSockets over SPDY is
     // implemented.
     NOTREACHED();
   } else if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
-    DCHECK(bidirectional_stream_job);
+    DCHECK(bidirectional_stream_impl);
     DCHECK(!stream);
-    delegate_->OnBidirectionalStreamJobReady(
+    delegate_->OnBidirectionalStreamImplReady(
         job->server_ssl_config(), job->proxy_info(),
-        bidirectional_stream_job.release());
+        bidirectional_stream_impl.release());
   } else {
-    DCHECK(!bidirectional_stream_job);
+    DCHECK(!bidirectional_stream_impl);
     DCHECK(stream);
     delegate_->OnStreamReady(job->server_ssl_config(), job->proxy_info(),
                              stream.release());
   }
   // |this| may be deleted after this point.
   if (spdy_session && spdy_session->IsAvailable()) {
     factory->OnNewSpdySessionReady(spdy_session,
                                    direct,
                                    used_ssl_config,
                                    used_proxy_info,
@@ skipping 76 matching lines @@
     }
     // We may have other jobs in |jobs_|. For example, if we start multiple jobs
     // for Alternate-Protocol.
     BindJob(job);
     return;
   }
   DCHECK(jobs_.empty());
 }
 
 }  // namespace net