[android_webview] Add more params to request intercepting.

android_webview/browser/net/android_stream_reader_url_request_job_unittest.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 "android_webview/browser/input_stream.h"
 #include "android_webview/browser/net/android_stream_reader_url_request_job.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/browser/net/input_stream_reader.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_byte_range.h"
+#include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_util.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using android_webview::InputStream;
 using android_webview::InputStreamReader;
 using net::TestDelegate;
 using net::TestJobInterceptor;
@@ skipping 61 matching lines @@
                            std::string* mime_type) OVERRIDE {
     return false;
   }
 
   virtual bool GetCharset(JNIEnv* env,
                           net::URLRequest* request,
                           android_webview::InputStream* stream,
                           std::string* charset) OVERRIDE {
     return false;
   }
+
+  virtual void UpdateHeaders(JNIEnv* env,
+                             net::HttpResponseHeaders* headers) OVERRIDE {
+    // no-op
+  }
 };
 
 class NullStreamReaderDelegate : public StreamReaderDelegate {
  public:
   NullStreamReaderDelegate() {}
 
   virtual scoped_ptr<InputStream> OpenInputStream(
       JNIEnv* env,
       const GURL& url) OVERRIDE {
     return make_scoped_ptr<InputStream>(NULL);
   }
 };
 
+class HeaderAlteringStreamReaderDelegate : public NullStreamReaderDelegate {
+ public:
+  HeaderAlteringStreamReaderDelegate() {}
+
+  virtual void UpdateHeaders(JNIEnv* env,
+                             net::HttpResponseHeaders* headers) OVERRIDE {
+    headers->ReplaceStatusLine(kStatusLine);
+    std::string headerLine(kCustomHeaderName);
+    headerLine.append(": ");
+    headerLine.append(kCustomHeaderValue);
+    headers->AddHeader(headerLine);
+  }
+
+  static const int kResponseCode;
+  static const char* kStatusLine;
+  static const char* kCustomHeaderName;
+  static const char* kCustomHeaderValue;
+};
+
+const int HeaderAlteringStreamReaderDelegate::kResponseCode = 401;
+const char* HeaderAlteringStreamReaderDelegate::kStatusLine =
+    "HTTP/1.1 401 Gone";
+const char* HeaderAlteringStreamReaderDelegate::kCustomHeaderName =
+    "X-Test-Header";
+const char* HeaderAlteringStreamReaderDelegate::kCustomHeaderValue =
+    "TestHeaderValue";
+
 class MockInputStreamReader : public InputStreamReader {
  public:
   MockInputStreamReader() : InputStreamReader(new NotImplInputStream()) {}
   ~MockInputStreamReader() {}
 
   MOCK_METHOD1(Seek, int(const net::HttpByteRange& byte_range));
   MOCK_METHOD2(ReadRawData, int(net::IOBuffer* buffer, int buffer_size));
 };
 
 
@@ skipping 119 matching lines @@
 
   // The request_failed() method is named confusingly but all it checks is
   // whether the request got as far as calling NotifyHeadersComplete.
   EXPECT_FALSE(url_request_delegate_.request_failed());
   EXPECT_EQ(1, network_delegate_.completed_requests());
   // A null input stream shouldn't result in an error. See crbug.com/180950.
   EXPECT_EQ(0, network_delegate_.error_count());
   EXPECT_EQ(404, req_->GetResponseCode());
 }
 
+TEST_F(AndroidStreamReaderURLRequestJobTest, ModifyHeadersAndStatus) {
+  SetUpTestJob(scoped_ptr<InputStreamReader>(),
+               make_scoped_ptr(new HeaderAlteringStreamReaderDelegate())
+                   .PassAs<AndroidStreamReaderURLRequestJob::Delegate>());
+  req_->Start();
+
+  // The TestDelegate will quit the message loop on request completion.
+  base::MessageLoop::current()->Run();
+
+  // The request_failed() method is named confusingly but all it checks is
+  // whether the request got as far as calling NotifyHeadersComplete.
+  EXPECT_FALSE(url_request_delegate_.request_failed());
+  EXPECT_EQ(1, network_delegate_.completed_requests());
+  // A null input stream shouldn't result in an error. See crbug.com/180950.
+  EXPECT_EQ(0, network_delegate_.error_count());
+  EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kResponseCode,
+            req_->GetResponseCode());
+  EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kStatusLine,
+            req_->response_headers()->GetStatusLine());
+  EXPECT_TRUE(req_->response_headers()->HasHeader(
+      HeaderAlteringStreamReaderDelegate::kCustomHeaderName));
+  std::string header_value;
+  EXPECT_TRUE(req_->response_headers()->EnumerateHeader(
+      NULL, HeaderAlteringStreamReaderDelegate::kCustomHeaderName,
+      &header_value));
+  EXPECT_EQ(HeaderAlteringStreamReaderDelegate::kCustomHeaderValue,
+            header_value);
+}
+
 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadPartOfStream) {
   const int bytes_available = 128;
   const int offset = 32;
   const int bytes_to_read = bytes_available - offset;
   scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader(
       new StrictMock<MockInputStreamReader>());
   {
     InSequence s;
     EXPECT_CALL(*stream_reader, Seek(_))
         .WillOnce(Return(bytes_available));
@@ skipping 90 matching lines @@
 
   SetRange(req_.get(), offset, bytes_available);
   req_->Start();
 
   loop.Run();
 
   EXPECT_EQ(0, network_delegate_.completed_requests());
   req_->Cancel();
   EXPECT_EQ(1, network_delegate_.completed_requests());
 }