Convert enable_bidirectional_stream into build flag local to net.

net/http/http_stream_factory_impl.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.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/log/net_log.h"
+#include "net/net_features.h"

[mmenke, 2016/01/04 21:50:36]

Why is this needed here, but not in, say,
net/http/http_stream_factory_impl_request.cc?  I had thought it was being
generated to include the define by the new rules, but maybe I was
misunderstanding things?

[mef, 2016/01/04 21:55:33]

I think your understanding matches mine. :) 
Without this include BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM) is triggering a
compilation error.
Which IMHO is a good thing.

It is not needed in net/http/http_stream_factory_impl_request.cc because it is
included in net/http/http_stream_factory_impl_request.h.

 #include "net/quic/quic_server_id.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "url/gurl.h"
 
-#if defined(ENABLE_BIDIRECTIONAL_STREAM)
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
 #include "net/spdy/bidirectional_stream_spdy_job.h"
 #endif
 
 namespace net {
 
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
       for_websockets_(for_websockets) {}
 
@@ skipping 52 matching lines @@
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     const BoundNetLog& net_log) {
   DCHECK(!for_websockets_);
   DCHECK(request_info.url.SchemeIs(url::kHttpsScheme));
 
 // TODO(xunjieli): Create QUIC's version of BidirectionalStreamJob.
-#if defined(ENABLE_BIDIRECTIONAL_STREAM)
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
   Request* request =
       new Request(request_info.url, this, delegate, nullptr, net_log,
                   Request::BIDIRECTIONAL_STREAM_SPDY_JOB);
   Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
                      proxy_ssl_config, net_log.net_log());
   request->AttachJob(job);
 
   job->Start(request);
   return request;
 
@@ skipping 194 matching lines @@
     // that it matters here.
     if (!ContainsKey(spdy_session_request_map_, spdy_session_key))
       break;
     Request* request = *spdy_session_request_map_[spdy_session_key].begin();
     request->Complete(was_npn_negotiated, protocol_negotiated, using_spdy);
     if (for_websockets_) {
       // TODO(ricea): Restore this code path when WebSocket over SPDY
       // implementation is ready.
       NOTREACHED();
     } else if (request->for_bidirectional()) {
-#if defined(ENABLE_BIDIRECTIONAL_STREAM)
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
       request->OnBidirectionalStreamJobReady(
           nullptr, used_ssl_config, used_proxy_info,
           new BidirectionalStreamSpdyJob(spdy_session));
 #else
       DCHECK(false);
 #endif
     } else {
       bool use_relative_url = direct || request->url().SchemeIs("https");
       request->OnStreamReady(
           nullptr, used_ssl_config, used_proxy_info,
           new SpdyHttpStream(spdy_session, use_relative_url));
     }
   }
   // TODO(mbelshe): Alert other valid requests.
 }
 
 void HttpStreamFactoryImpl::OnOrphanedJobComplete(const Job* job) {
   orphaned_job_set_.erase(job);
   delete job;
 }
 
 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
   preconnect_job_set_.erase(job);
   delete job;
   OnPreconnectsCompleteInternal();
 }
 
 }  // namespace net