Add read-only access to POST data for webRequest's onBeforeRequest

chrome/browser/extensions/api/web_request/web_request_api_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 <queue>
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 55 matching lines @@
 }
 
 // Searches |key| in |collection| by iterating over its elements and returns
 // true if found.
 template <typename Collection, typename Key>
 bool Contains(const Collection& collection, const Key& key) {
   return std::find(collection.begin(), collection.end(), key) !=
       collection.end();
 }
 
+// Inspects the data attached to the |message| and tries to extract its
+// "keys::kFormDataKey" section into |form_data|. Returns true on success.
+bool GetFormData(IPC::Message* message, std::string* form_data) {
+  CHECK(message->type() == ExtensionMsg_MessageInvoke::ID);
+  ExtensionMsg_MessageInvoke::Param param;
+  Value* temp_value = NULL;
+  CHECK(ExtensionMsg_MessageInvoke::Read(message, &param));
+  CHECK(param.c.GetSize() >= 2);
+  CHECK(param.c.Get(1, &temp_value));
+  std::string args;
+  CHECK(temp_value->GetAsString(&args));
+
+  const std::string kFormDataHead(
+      std::string("\"") + keys::kFormDataKey + "\":{");
+  size_t form_data_start = args.find(kFormDataHead);
+  if (form_data_start == std::string::npos)
+    return false;
+  form_data_start += kFormDataHead.size();
+
+  const size_t form_data_end = args.find("}", form_data_start);
+  CHECK(form_data_end != std::string::npos);
+  const size_t form_data_length = form_data_end - form_data_start;
+  *form_data = std::string(args, form_data_start, form_data_length);
+  return true;
+}
+
 }  // namespace
 
 // A mock event router that responds to events with a pre-arranged queue of
 // Tasks.
 class TestIPCSender : public IPC::Sender {
  public:
   typedef std::list<linked_ptr<IPC::Message> > SentMessages;
 
   // Adds a Task to the queue. We will fire these in order as events are
   // dispatched.
@@ skipping 40 matching lines @@
     enable_referrers_.Init(
         prefs::kEnableReferrers, profile_.GetTestingPrefService(), NULL);
     network_delegate_.reset(new ChromeNetworkDelegate(
         event_router_.get(), NULL, NULL, &profile_,
         CookieSettings::Factory::GetForProfile(&profile_), &enable_referrers_));
     context_.reset(new TestURLRequestContext(true));
     context_->set_network_delegate(network_delegate_.get());
     context_->Init();
   }
 
+  // Fires a URLRequest with the specified |content_type|. Method will be "POST"
+  // and the data will be |bytes|.
+  void FireURLRequestWithPostData(const char* content_type, const char* bytes);
+
   MessageLoopForIO message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
   TestingProfile profile_;
   TestDelegate delegate_;
   BooleanPrefMember enable_referrers_;
   TestIPCSender ipc_sender_;
   scoped_refptr<ExtensionEventRouterForwarder> event_router_;
   scoped_refptr<ExtensionInfoMap> extension_info_map_;
   scoped_ptr<ChromeNetworkDelegate> network_delegate_;
@@ skipping 245 matching lines @@
   EXPECT_TRUE(!request.is_pending());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, request.status().status());
   EXPECT_EQ(net::ERR_ABORTED, request.status().error());
   EXPECT_EQ(request_url, request.url());
   EXPECT_EQ(1U, request.url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
 
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension_id, kEventName + "/1");
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
-        &profile_, extension_id, kEventName2 + "/1");
+      &profile_, extension_id, kEventName2 + "/1");
+}
+
+void ExtensionWebRequestTest::FireURLRequestWithPostData(
+    const char* content_type,
+    const char* bytes) {
+  // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
+  GURL request_url("http://www.example.com");
+  net::URLRequest request(request_url, &delegate_, context_.get());
+  request.set_method("POST");
+  request.SetExtraRequestHeaderByName("Content-Type", content_type, true);
+  request.AppendBytesToUpload(bytes, strlen(bytes));
+  ipc_sender_.PushTask(base::Bind(&base::DoNothing));
+  request.Start();
+}
+
+TEST_F(ExtensionWebRequestTest, AccessPostData) {
+  // We verify that POST data are accessible to OnBeforeRequest listeners.
+  // Construct the test data.
+#define kBoundary "THIS_IS_A_BOUNDARY"
+#define kBlock "--" kBoundary "\r\n" \
+    "Content-Disposition: form-data; name=\"text\"\r\n" \
+    "\r\n" \
+    "test text\r\n" \
+    "--" kBoundary "--"
+  // POST data input.
+  const char kMultipartBytes[] = kBlock;
+  // POST data output.
+  const char kResultString[] = "\"text\":[\"test text\"]";
+  // Header.
+  const char kMultipart[] = "multipart/form-data; boundary=" kBoundary;
+#undef kBlock
+#undef kBoundary
+  bool kSuccessExpected[] = {true, false};
+
+  // Set up a dummy extension name.
+  ExtensionWebRequestEventRouter::RequestFilter filter;
+  std::string extension_id("1");
+  int extra_info_spec_post =
+      ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING |
+      ExtensionWebRequestEventRouter::ExtraInfoSpec::REQUEST_POST_DATA;
+  int extra_info_spec_no_post =
+      ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING;
+
+  // Subscribe to OnBeforeRequest with POST data requirement.
+  const std::string kEventName(keys::kOnBeforeRequest);
+  base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
+  ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
+      &profile_, extension_id, extension_id, kEventName, kEventName + "/1",
+      filter, extra_info_spec_post, ipc_sender_factory.GetWeakPtr());
+
+  FireURLRequestWithPostData(kMultipart, kMultipartBytes);
+
+  MessageLoop::current()->RunAllPending();
+
+  // Now remove the requirement of POST data.
+  ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
+      &profile_, extension_id, kEventName + "/1");
+  ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
+      &profile_, extension_id, extension_id, kEventName, kEventName + "/1",
+      filter, extra_info_spec_no_post, ipc_sender_factory.GetWeakPtr());
+
+  FireURLRequestWithPostData(kMultipart, kMultipartBytes);
+
+  MessageLoop::current()->RunAllPending();
+
+  IPC::Message* message = NULL;
+  std::string form_data;
+  TestIPCSender::SentMessages::const_iterator i = ipc_sender_.sent_begin();
+  for (size_t test = 0; test < arraysize(kSuccessExpected); ++test) {
+    EXPECT_NE(i, ipc_sender_.sent_end());
+    message = (i++)->get();
+    if (kSuccessExpected[test]) {
+      EXPECT_TRUE(GetFormData(message, &form_data)) << test;
+      EXPECT_EQ(kResultString, form_data);
+    } else {
+      EXPECT_FALSE(GetFormData(message, &form_data));
+    }
+  }
+
+  EXPECT_EQ(i, ipc_sender_.sent_end());
+
+  // Clean-up.
+  ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
+      &profile_, extension_id, kEventName + "/1");
 }
 
 struct HeaderModificationTest_Header {
   const char* name;
   const char* value;
 };
 
 struct HeaderModificationTest_Modification {
   enum Type {
     SET,
@@ skipping 244 matching lines @@
       true,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::RESPONSE_HEADERS);
   TestInitFromValue(
       "blocking",
       true,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING);
   TestInitFromValue(
       "asyncBlocking",
       true,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::ASYNC_BLOCKING);
+  TestInitFromValue(
+      "requestPostData",
+      true,
+      ExtensionWebRequestEventRouter::ExtraInfoSpec::REQUEST_POST_DATA);
 
   // Multiple valid values are bitwise-or'ed.
   TestInitFromValue(
       "requestHeaders,blocking",
       true,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::REQUEST_HEADERS |
       ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING);
 
   // Any invalid values lead to a bad parse.
   TestInitFromValue("invalidValue", false, 0);
@@ skipping 849 matching lines @@
   // Check that requests are rejected if their first party url is sensitive.
   ASSERT_GE(arraysize(non_sensitive_urls), 1u);
   GURL non_sensitive_url(non_sensitive_urls[0]);
   for (size_t i = 0; i < arraysize(sensitive_urls); ++i) {
     TestURLRequest request(non_sensitive_url, NULL, &context);
     GURL sensitive_url(sensitive_urls[i]);
     request.set_first_party_for_cookies(sensitive_url);
     EXPECT_TRUE(helpers::HideRequest(&request)) << sensitive_urls[i];
   }
 }