chrome/browser/net/http_pipelining_compatibility_client.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
   6
   7 #include "base/metrics/field_trial.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_split.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "chrome/browser/io_thread.h"
  13 #include "chrome/common/chrome_version_info.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "net/base/load_flags.h"
  16 #include "net/base/network_change_notifier.h"
  17 #include "net/base/request_priority.h"
  18 #include "net/disk_cache/histogram_macros.h"
  19 #include "net/http/http_network_layer.h"
  20 #include "net/http/http_network_session.h"
  21 #include "net/http/http_response_headers.h"
  22 #include "net/http/http_version.h"
  23 #include "net/proxy/proxy_config.h"
  24 #include "net/proxy/proxy_service.h"
  25 #include "net/url_request/url_request_context.h"
  26 #include "net/url_request/url_request_context_getter.h"
  27
  28 namespace chrome_browser_net {
  29
  30 static const int kCanaryRequestId = 999;
  31
  32 namespace {
  33
  34 // There is one Request per RequestInfo passed in to Start() above.
  35 class Request : public internal::PipelineTestRequest,
  36                 public net::URLRequest::Delegate {
  37  public:
  38   Request(int request_id,
  39           const std::string& base_url,
  40           const RequestInfo& info,
  41           internal::PipelineTestRequest::Delegate* delegate,
  42           net::URLRequestContext* url_request_context);
  43
  44   virtual ~Request() {}
  45
  46   virtual void Start() OVERRIDE;
  47
  48  protected:
  49   // Called when this request has determined its result. Returns the result to
  50   // the |client_|.
  51   virtual void Finished(internal::PipelineTestRequest::Status result);
  52
  53   const std::string& response() const { return response_; }
  54
  55   internal::PipelineTestRequest::Delegate* delegate() { return delegate_; }
  56
  57  private:
  58   // Called when a response can be read. Reads bytes into |response_| until it
  59   // consumes the entire response or it encounters an error.
  60   void DoRead();
  61
  62   // Called when all bytes have been received. Compares the |response_| to
  63   // |info_|'s expected response.
  64   virtual void DoReadFinished();
  65
  66   // net::URLRequest::Delegate interface
  67   virtual void OnReceivedRedirect(net::URLRequest* request,
  68                                   const GURL& new_url,
  69                                   bool* defer_redirect) OVERRIDE;
  70   virtual void OnSSLCertificateError(net::URLRequest* request,
  71                                      const net::SSLInfo& ssl_info,
  72                                      bool fatal) OVERRIDE;
  73   virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE;
  74   virtual void OnReadCompleted(net::URLRequest* request,
  75                                int bytes_read) OVERRIDE;
  76
  77   internal::PipelineTestRequest::Delegate* delegate_;
  78   const int request_id_;
  79   scoped_ptr<net::URLRequest> url_request_;
  80   const RequestInfo info_;
  81   scoped_refptr<net::IOBuffer> read_buffer_;
  82   std::string response_;
  83   int response_code_;
  84 };
  85
  86 Request::Request(int request_id,
  87                  const std::string& base_url,
  88                  const RequestInfo& info,
  89                  internal::PipelineTestRequest::Delegate* delegate,
  90                  net::URLRequestContext* url_request_context)
  91     : delegate_(delegate),
  92       request_id_(request_id),
  93       url_request_(url_request_context->CreateRequest(GURL(base_url +
  94                                                            info.filename),
  95                                                       net::DEFAULT_PRIORITY,
  96                                                       this)),
  97       info_(info),
  98       response_code_(0) {
  99   url_request_->SetLoadFlags(net::LOAD_BYPASS_CACHE |
 100                              net::LOAD_DISABLE_CACHE |
 101                              net::LOAD_DO_NOT_SAVE_COOKIES |
 102                              net::LOAD_DO_NOT_SEND_COOKIES |
 103                              net::LOAD_DO_NOT_PROMPT_FOR_LOGIN |
 104                              net::LOAD_DO_NOT_SEND_AUTH_DATA);
 105 }
 106
 107 void Request::Start() {
 108   url_request_->Start();
 109 }
 110
 111 void Request::OnReceivedRedirect(
 112     net::URLRequest* request,
 113     const GURL& new_url,
 114     bool* defer_redirect) {
 115   *defer_redirect = true;
 116   request->Cancel();
 117   Finished(STATUS_REDIRECTED);
 118 }
 119
 120 void Request::OnSSLCertificateError(
 121     net::URLRequest* request,
 122     const net::SSLInfo& ssl_info,
 123     bool fatal) {
 124   Finished(STATUS_CERT_ERROR);
 125 }
 126
 127 void Request::OnResponseStarted(net::URLRequest* request) {
 128   response_code_ = request->GetResponseCode();
 129   if (response_code_ != 200) {
 130     Finished(STATUS_BAD_RESPONSE_CODE);
 131     return;
 132   }
 133   const net::HttpVersion required_version(1, 1);
 134   if (request->response_info().headers->GetParsedHttpVersion() <
 135       required_version) {
 136     Finished(STATUS_BAD_HTTP_VERSION);
 137     return;
 138   }
 139   read_buffer_ = new net::IOBuffer(info_.expected_response.length());
 140   DoRead();
 141 }
 142
 143 void Request::OnReadCompleted(net::URLRequest* request, int bytes_read) {
 144   if (bytes_read == 0) {
 145     DoReadFinished();
 146   } else if (bytes_read < 0) {
 147     Finished(STATUS_NETWORK_ERROR);
 148   } else {
 149     response_.append(read_buffer_->data(), bytes_read);
 150     if (response_.length() <= info_.expected_response.length()) {
 151       DoRead();
 152     } else if (response_.find(info_.expected_response) == 0) {
 153       Finished(STATUS_TOO_LARGE);
 154     } else {
 155       Finished(STATUS_CONTENT_MISMATCH);
 156     }
 157   }
 158 }
 159
 160 void Request::DoRead() {
 161   int bytes_read = 0;
 162   if (url_request_->Read(read_buffer_.get(), info_.expected_response.length(),
 163                          &bytes_read)) {
 164     OnReadCompleted(url_request_.get(), bytes_read);
 165   }
 166 }
 167
 168 void Request::DoReadFinished() {
 169   if (response_.length() != info_.expected_response.length()) {
 170     if (info_.expected_response.find(response_) == 0) {
 171       Finished(STATUS_TOO_SMALL);
 172     } else {
 173       Finished(STATUS_CONTENT_MISMATCH);
 174     }
 175   } else if (response_ == info_.expected_response) {
 176     Finished(STATUS_SUCCESS);
 177   } else {
 178     Finished(STATUS_CONTENT_MISMATCH);
 179   }
 180 }
 181
 182 void Request::Finished(internal::PipelineTestRequest::Status result) {
 183   const net::URLRequestStatus status = url_request_->status();
 184   url_request_.reset();
 185   if (response_code_ > 0) {
 186     delegate()->ReportResponseCode(request_id_, response_code_);
 187   }
 188   if (status.status() == net::URLRequestStatus::FAILED) {
 189     // Network errors trump all other status codes, because network errors can
 190     // be detected by the network stack even with real content. If we determine
 191     // that all pipelining errors can be detected by the network stack, then we
 192     // don't need to worry about broken proxies.
 193     delegate()->ReportNetworkError(request_id_, status.error());
 194     delegate()->OnRequestFinished(request_id_, STATUS_NETWORK_ERROR);
 195   } else {
 196     delegate()->OnRequestFinished(request_id_, result);
 197   }
 198   // WARNING: We may be deleted at this point.
 199 }
 200
 201 // A special non-pipelined request sent before pipelining begins to test basic
 202 // HTTP connectivity.
 203 class CanaryRequest : public Request {
 204  public:
 205   CanaryRequest(int request_id,
 206                const std::string& base_url,
 207                const RequestInfo& info,
 208                internal::PipelineTestRequest::Delegate* delegate,
 209                net::URLRequestContext* url_request_context)
 210       : Request(request_id, base_url, info, delegate, url_request_context) {
 211   }
 212
 213   virtual ~CanaryRequest() {}
 214
 215  private:
 216   virtual void Finished(
 217       internal::PipelineTestRequest::Status result) OVERRIDE {
 218     delegate()->OnCanaryFinished(result);
 219   }
 220 };
 221
 222 // A special request that parses a /stats.txt response from the test server.
 223 class StatsRequest : public Request {
 224  public:
 225   // Note that |info.expected_response| is only used to determine the correct
 226   // length of the response. The exact string content isn't used.
 227   StatsRequest(int request_id,
 228                const std::string& base_url,
 229                const RequestInfo& info,
 230                internal::PipelineTestRequest::Delegate* delegate,
 231                net::URLRequestContext* url_request_context)
 232       : Request(request_id, base_url, info, delegate, url_request_context) {
 233   }
 234
 235   virtual ~StatsRequest() {}
 236
 237  private:
 238   virtual void DoReadFinished() OVERRIDE {
 239     internal::PipelineTestRequest::Status status =
 240         internal::ProcessStatsResponse(response());
 241     Finished(status);
 242   }
 243 };
 244
 245 class RequestFactory : public internal::PipelineTestRequest::Factory {
 246  public:
 247   virtual internal::PipelineTestRequest* NewRequest(
 248       int request_id,
 249       const std::string& base_url,
 250       const RequestInfo& info,
 251       internal::PipelineTestRequest::Delegate* delegate,
 252       net::URLRequestContext* url_request_context,
 253       internal::PipelineTestRequest::Type request_type) OVERRIDE {
 254     switch (request_type) {
 255       case internal::PipelineTestRequest::TYPE_PIPELINED:
 256         return new Request(request_id, base_url, info, delegate,
 257                            url_request_context);
 258
 259       case internal::PipelineTestRequest::TYPE_CANARY:
 260         return new CanaryRequest(request_id, base_url, info, delegate,
 261                                  url_request_context);
 262
 263       case internal::PipelineTestRequest::TYPE_STATS:
 264         return new StatsRequest(request_id, base_url, info, delegate,
 265                                 url_request_context);
 266
 267       default:
 268         NOTREACHED();
 269         return NULL;
 270     }
 271   }
 272 };
 273
 274 }  // anonymous namespace
 275
 276 HttpPipeliningCompatibilityClient::HttpPipeliningCompatibilityClient(
 277     internal::PipelineTestRequest::Factory* factory)
 278     : factory_(factory),
 279       num_finished_(0),
 280       num_succeeded_(0) {
 281   if (!factory_.get()) {
 282     factory_.reset(new RequestFactory);
 283   }
 284 }
 285
 286 HttpPipeliningCompatibilityClient::~HttpPipeliningCompatibilityClient() {
 287 }
 288
 289 void HttpPipeliningCompatibilityClient::Start(
 290     const std::string& base_url,
 291     std::vector<RequestInfo>& requests,
 292     Options options,
 293     const net::CompletionCallback& callback,
 294     net::URLRequestContext* url_request_context) {
 295   net::HttpNetworkSession* old_session =
 296       url_request_context->http_transaction_factory()->GetSession();
 297   net::HttpNetworkSession::Params params = old_session->params();
 298   params.force_http_pipelining = true;
 299   scoped_refptr<net::HttpNetworkSession> session =
 300       new net::HttpNetworkSession(params);
 301   http_transaction_factory_.reset(
 302       net::HttpNetworkLayer::CreateFactory(session.get()));
 303
 304   url_request_context_.reset(new net::URLRequestContext);
 305   url_request_context_->CopyFrom(url_request_context);
 306   url_request_context_->set_http_transaction_factory(
 307       http_transaction_factory_.get());
 308
 309   finished_callback_ = callback;
 310   for (size_t i = 0; i < requests.size(); ++i) {
 311     requests_.push_back(factory_->NewRequest(
 312         i, base_url, requests[i], this, url_request_context_.get(),
 313         internal::PipelineTestRequest::TYPE_PIPELINED));
 314   }
 315   if (options == PIPE_TEST_COLLECT_SERVER_STATS ||
 316       options == PIPE_TEST_CANARY_AND_STATS) {
 317     RequestInfo info;
 318     info.filename = "stats.txt";
 319     // This is just to determine the expected length of the response.
 320     // StatsRequest doesn't expect this exact value, but it does expect this
 321     // exact length.
 322     info.expected_response =
 323         "were_all_requests_http_1_1:1,max_pipeline_depth:5";
 324     requests_.push_back(factory_->NewRequest(
 325         requests.size(), base_url, info, this, url_request_context_.get(),
 326         internal::PipelineTestRequest::TYPE_STATS));
 327   }
 328   if (options == PIPE_TEST_RUN_CANARY_REQUEST ||
 329       options == PIPE_TEST_CANARY_AND_STATS) {
 330     RequestInfo info;
 331     info.filename = "index.html";
 332     info.expected_response =
 333         "\nThis is a test server operated by Google. It's used by Google "
 334         "Chrome to test\nproxies for compatibility with HTTP pipelining. More "
 335         "information can be found\nhere:\n\nhttp://dev.chromium.org/developers/"
 336         "design-documents/network-stack/http-pipelining\n\nSource code can be "
 337         "found here:\n\nhttp://code.google.com/p/http-pipelining-test/\n";
 338     canary_request_.reset(factory_->NewRequest(
 339         kCanaryRequestId, base_url, info, this, url_request_context,
 340         internal::PipelineTestRequest::TYPE_CANARY));
 341     canary_request_->Start();
 342   } else {
 343     StartTestRequests();
 344   }
 345 }
 346
 347 void HttpPipeliningCompatibilityClient::StartTestRequests() {
 348   for (size_t i = 0; i < requests_.size(); ++i) {
 349     requests_[i]->Start();
 350   }
 351 }
 352
 353 void HttpPipeliningCompatibilityClient::OnCanaryFinished(
 354     internal::PipelineTestRequest::Status status) {
 355   canary_request_.reset();
 356   bool success = (status == internal::PipelineTestRequest::STATUS_SUCCESS);
 357   UMA_HISTOGRAM_BOOLEAN("NetConnectivity.Pipeline.CanarySuccess", success);
 358   if (success) {
 359     StartTestRequests();
 360   } else {
 361     finished_callback_.Run(0);
 362   }
 363 }
 364
 365 void HttpPipeliningCompatibilityClient::OnRequestFinished(
 366     int request_id, internal::PipelineTestRequest::Status status) {
 367   // The CACHE_HISTOGRAM_* macros are used, because they allow dynamic metric
 368   // names.
 369   CACHE_HISTOGRAM_ENUMERATION(GetMetricName(request_id, "Status"),
 370                               status,
 371                               internal::PipelineTestRequest::STATUS_MAX);
 372
 373   ++num_finished_;
 374   if (status == internal::PipelineTestRequest::STATUS_SUCCESS) {
 375     ++num_succeeded_;
 376   }
 377   if (num_finished_ == requests_.size()) {
 378     UMA_HISTOGRAM_BOOLEAN("NetConnectivity.Pipeline.Success",
 379                           num_succeeded_ == requests_.size());
 380     finished_callback_.Run(0);
 381   }
 382 }
 383
 384 void HttpPipeliningCompatibilityClient::ReportNetworkError(int request_id,
 385                                                            int error_code) {
 386   CACHE_HISTOGRAM_ENUMERATION(GetMetricName(request_id, "NetworkError"),
 387                               -error_code, 900);
 388 }
 389
 390 void HttpPipeliningCompatibilityClient::ReportResponseCode(int request_id,
 391                                                            int response_code) {
 392   CACHE_HISTOGRAM_ENUMERATION(GetMetricName(request_id, "ResponseCode"),
 393                               response_code, 600);
 394 }
 395
 396 std::string HttpPipeliningCompatibilityClient::GetMetricName(
 397     int request_id, const char* description) {
 398   return base::StringPrintf("NetConnectivity.Pipeline.%d.%s",
 399                             request_id, description);
 400 }
 401
 402 namespace internal {
 403
 404 internal::PipelineTestRequest::Status ProcessStatsResponse(
 405     const std::string& response) {
 406   bool were_all_requests_http_1_1 = false;
 407   int max_pipeline_depth = 0;
 408
 409   std::vector<std::pair<std::string, std::string> > kv_pairs;
 410   base::SplitStringIntoKeyValuePairs(response, ':', ',', &kv_pairs);
 411
 412   if (kv_pairs.size() != 2) {
 413     return internal::PipelineTestRequest::STATUS_CORRUPT_STATS;
 414   }
 415
 416   for (size_t i = 0; i < kv_pairs.size(); ++i) {
 417     const std::string& key = kv_pairs[i].first;
 418     int value;
 419     if (!base::StringToInt(kv_pairs[i].second, &value)) {
 420       return internal::PipelineTestRequest::STATUS_CORRUPT_STATS;
 421     }
 422
 423     if (key == "were_all_requests_http_1_1") {
 424       were_all_requests_http_1_1 = (value == 1);
 425     } else if (key == "max_pipeline_depth") {
 426       max_pipeline_depth = value;
 427     } else {
 428       return internal::PipelineTestRequest::STATUS_CORRUPT_STATS;
 429     }
 430   }
 431
 432   UMA_HISTOGRAM_BOOLEAN("NetConnectivity.Pipeline.AllHTTP11",
 433                         were_all_requests_http_1_1);
 434   UMA_HISTOGRAM_ENUMERATION("NetConnectivity.Pipeline.Depth",
 435                             max_pipeline_depth, 6);
 436
 437   return internal::PipelineTestRequest::STATUS_SUCCESS;
 438 }
 439
 440 }  // namespace internal
 441
 442 namespace {
 443
 444 void DeleteClient(IOThread* io_thread, int /* rv */) {
 445   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 446   io_thread->globals()->http_pipelining_compatibility_client.reset();
 447 }
 448
 449 void CollectPipeliningCapabilityStatsOnIOThread(
 450     const std::string& pipeline_test_server,
 451     IOThread* io_thread) {
 452   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
 453
 454   net::URLRequestContext* url_request_context =
 455       io_thread->globals()->system_request_context.get();
 456   if (!url_request_context->proxy_service()->config().proxy_rules().empty()) {
 457     // Pipelining with explicitly configured proxies is disabled for now.
 458     return;
 459   }
 460
 461   const base::FieldTrial::Probability kDivisor = 100;
 462   base::FieldTrial::Probability probability_to_run_test = 0;
 463
 464   const char* kTrialName = "HttpPipeliningCompatibility";
 465   base::FieldTrial* trial = base::FieldTrialList::Find(kTrialName);
 466   if (trial) {
 467     return;
 468   }
 469   // After May 4, 2012, the trial will disable itself.
 470   trial = base::FieldTrialList::FactoryGetFieldTrial(
 471       kTrialName, kDivisor, "disable_test", 2012, 5, 4,
 472       base::FieldTrial::SESSION_RANDOMIZED, NULL);
 473
 474   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
 475   if (channel == chrome::VersionInfo::CHANNEL_CANARY) {
 476     probability_to_run_test = 100;
 477   } else if (channel == chrome::VersionInfo::CHANNEL_DEV) {
 478     probability_to_run_test = 100;
 479   }
 480
 481   int collect_stats_group = trial->AppendGroup("enable_test",
 482                                                probability_to_run_test);
 483   if (trial->group() != collect_stats_group) {
 484     return;
 485   }
 486
 487   std::vector<RequestInfo> requests;
 488
 489   RequestInfo info0;
 490   info0.filename = "alphabet.txt";
 491   info0.expected_response = "abcdefghijklmnopqrstuvwxyz";
 492   requests.push_back(info0);
 493
 494   RequestInfo info1;
 495   info1.filename = "cached.txt";
 496   info1.expected_response = "azbycxdwevfugthsirjqkplomn";
 497   requests.push_back(info1);
 498
 499   RequestInfo info2;
 500   info2.filename = "reverse.txt";
 501   info2.expected_response = "zyxwvutsrqponmlkjihgfedcba";
 502   requests.push_back(info2);
 503
 504   RequestInfo info3;
 505   info3.filename = "chunked.txt";
 506   info3.expected_response = "chunkedencodingisfun";
 507   requests.push_back(info3);
 508
 509   RequestInfo info4;
 510   info4.filename = "cached.txt";
 511   info4.expected_response = "azbycxdwevfugthsirjqkplomn";
 512   requests.push_back(info4);
 513
 514   HttpPipeliningCompatibilityClient* client =
 515       new HttpPipeliningCompatibilityClient(NULL);
 516   client->Start(pipeline_test_server, requests,
 517                 HttpPipeliningCompatibilityClient::PIPE_TEST_CANARY_AND_STATS,
 518                 base::Bind(&DeleteClient, io_thread),
 519                 url_request_context);
 520   io_thread->globals()->http_pipelining_compatibility_client.reset(client);
 521 }
 522
 523 }  // anonymous namespace
 524
 525 void CollectPipeliningCapabilityStatsOnUIThread(
 526     const std::string& pipeline_test_server, IOThread* io_thread) {
 527   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 528   if (pipeline_test_server.empty())
 529     return;
 530
 531   content::BrowserThread::PostTask(
 532       content::BrowserThread::IO,
 533       FROM_HERE,
 534       base::Bind(&CollectPipeliningCapabilityStatsOnIOThread,
 535                  pipeline_test_server,
 536                  io_thread));
 537 }
 538
 539 }  // namespace chrome_browser_net