[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;

[benm (inactive), 2014/05/15 16:17:40]

are there any headers that we shouldn't allow the app to spoof, or are their
special headers like Referer that we should test here (as there's special
handing for them in chromium).

(I seem to recall there is a header that CTS ensures the app can't overwrite via
the loadUrl overload...)

[mkosiba (inactive), 2014/05/15 17:03:21]

That's a good question. I'm not sure there is a lot of 'security' value in
preventing the app from spoofing headers. They can do that already by
intercepting the request and issuing a completely separate request from a custom
network stack.

There might be cases were they can shoot themselves in the foot (maybe something
like appending to content-length?). There is a list of 'dangerous' headers that
web pages shouldn't set here:
http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader()-method but most of
that seem like 'stuff we need to prevent untrusted code from doing to maintain
the security model' rather than 'touch any of these and everything breaks'.

I'll expand the test a bit but the app can't overwrite any headers. It can only
append so the worst that can happen is that the header contains more than one
value.
testCanInjectHeaders? It seems to check the exact opposite.

+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());
 }