[Extensions] Use a separate IPC message for extension events

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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
@@ skipping 108 matching lines @@
                 const std::string& extension_id) {
   for (WarningSet::const_iterator i = warnings.begin();
        i != warnings.end(); ++i) {
     if (i->extension_id() == extension_id)
       return true;
   }
   return false;
 }
 
 // Parses the JSON data attached to the |message| and tries to return it.
-// |param| must outlive |out|. Returns NULL on failure.
+// |param| must outlive |out|.
 void GetPartOfMessageArguments(IPC::Message* message,
                                const base::DictionaryValue** out,
-                               ExtensionMsg_MessageInvoke::Param* param) {
-  ASSERT_EQ(ExtensionMsg_MessageInvoke::ID, message->type());
-  ASSERT_TRUE(ExtensionMsg_MessageInvoke::Read(message, param));
-  ASSERT_GE(std::get<3>(*param).GetSize(), 2u);
-  const base::Value* value = NULL;
-  ASSERT_TRUE(std::get<3>(*param).Get(1, &value));
-  const base::ListValue* list = NULL;
-  ASSERT_TRUE(value->GetAsList(&list));
-  ASSERT_EQ(1u, list->GetSize());
-  ASSERT_TRUE(list->GetDictionary(0, out));
+                               ExtensionMsg_DispatchEvent::Param* param) {
+  ASSERT_EQ(ExtensionMsg_DispatchEvent::ID, message->type());
+  ASSERT_TRUE(ExtensionMsg_DispatchEvent::Read(message, param));
+  const base::ListValue& list = std::get<1>(*param);
+  ASSERT_EQ(1u, list.GetSize());
+  ASSERT_TRUE(list.GetDictionary(0, out));
 }
 
 }  // 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.
   void PushTask(const base::Closure& task) {
     task_queue_.push(task);
   }
 
   size_t GetNumTasks() { return task_queue_.size(); }
 
   SentMessages::const_iterator sent_begin() const {
     return sent_messages_.begin();
   }
 
   SentMessages::const_iterator sent_end() const {
     return sent_messages_.end();
   }
 
  private:
   // IPC::Sender
   bool Send(IPC::Message* message) override {
-    EXPECT_EQ(ExtensionMsg_MessageInvoke::ID, message->type());
+    EXPECT_EQ(ExtensionMsg_DispatchEvent::ID, message->type());
 
     EXPECT_FALSE(task_queue_.empty());
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   task_queue_.front());
     task_queue_.pop();
 
     sent_messages_.push_back(linked_ptr<IPC::Message>(message));
     return true;
   }
 
@@ skipping 510 matching lines @@
   // Clean-up.
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(id1,
                                                                      false);
 
   IPC::Message* message = NULL;
   TestIPCSender::SentMessages::const_iterator i = ipc_sender_.sent_begin();
   for (size_t test = 0; test < arraysize(kExpected); ++test) {
     SCOPED_TRACE(testing::Message("iteration number ") << test);
     EXPECT_NE(i, ipc_sender_.sent_end());
     message = (i++)->get();
-    const base::DictionaryValue* details;
-    ExtensionMsg_MessageInvoke::Param param;
+    const base::DictionaryValue* details = nullptr;
+    ExtensionMsg_DispatchEvent::Param param;
     GetPartOfMessageArguments(message, &details, &param);
     ASSERT_TRUE(details != NULL);
     const base::Value* result = NULL;
     if (kExpected[test]) {
       EXPECT_TRUE(details->Get(*(kPath[test]), &result));
       EXPECT_TRUE(kExpected[test]->Equals(result));
     } else {
       EXPECT_FALSE(details->Get(*(kPath[test]), &result));
     }
   }
@@ skipping 70 matching lines @@
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(id4,
                                                                      false);
 
   TestIPCSender::SentMessages::const_iterator i = ipc_sender_.sent_begin();
 
   for (size_t test = 0; test < arraysize(kExpected); ++test, ++i) {
     SCOPED_TRACE(testing::Message("iteration number ") << test);
     EXPECT_NE(i, ipc_sender_.sent_end());
     IPC::Message* message = i->get();
     const base::DictionaryValue* details = nullptr;
-    ExtensionMsg_MessageInvoke::Param param;
+    ExtensionMsg_DispatchEvent::Param param;
     GetPartOfMessageArguments(message, &details, &param);
     ASSERT_TRUE(details != nullptr);
     EXPECT_EQ(kExpected[test], details->HasKey(keys::kRequestBodyKey));
   }
 
   EXPECT_EQ(i, ipc_sender_.sent_end());
 }
 
 TEST_F(ExtensionWebRequestTest, NoAccessRequestBodyData) {
   // We verify that URLRequest body is NOT accessible to OnBeforeRequest
@@ skipping 35 matching lines @@
   ExtensionWebRequestEventRouter::EventListener::ID id1(
       &profile_, extension_id, kEventName + "/1", 0, 0);
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(id1,
                                                                      false);
 
   TestIPCSender::SentMessages::const_iterator i = ipc_sender_.sent_begin();
   for (size_t test = 0; test < arraysize(kMethods); ++test, ++i) {
     SCOPED_TRACE(testing::Message("iteration number ") << test);
     EXPECT_NE(i, ipc_sender_.sent_end());
     IPC::Message* message = i->get();
-    const base::DictionaryValue* details = NULL;
-    ExtensionMsg_MessageInvoke::Param param;
+    const base::DictionaryValue* details = nullptr;
+    ExtensionMsg_DispatchEvent::Param param;
     GetPartOfMessageArguments(message, &details, &param);
     ASSERT_TRUE(details != NULL);
     EXPECT_FALSE(details->HasKey(keys::kRequestBodyKey));
   }
 
   EXPECT_EQ(i, ipc_sender_.sent_end());
 }
 
 // Tests that |embedder_process_id| is not relevant for adding and removing
 // listeners with |web_view_instance_id| = 0.
@@ skipping 269 matching lines @@
   }
 
   // Counter for the number of observed onSendHeaders events.
   int num_headers_observed = 0;
 
   // Search the onSendHeaders signal in the IPC messages and check that
   // it contained the correct headers.
   TestIPCSender::SentMessages::const_iterator i;
   for (i = ipc_sender_.sent_begin(); i != ipc_sender_.sent_end(); ++i) {
     IPC::Message* message = i->get();
-    if (ExtensionMsg_MessageInvoke::ID != message->type())
+    if (ExtensionMsg_DispatchEvent::ID != message->type())
       continue;
-    ExtensionMsg_MessageInvoke::Param message_tuple;
-    ExtensionMsg_MessageInvoke::Read(message, &message_tuple);
-    base::ListValue& args = std::get<3>(message_tuple);
+    ExtensionMsg_DispatchEvent::Param message_tuple;
+    ExtensionMsg_DispatchEvent::Read(message, &message_tuple);
+    const ExtensionMsg_DispatchEvent_Params& params =
+        std::get<0>(message_tuple);
 
-    std::string event_name;
-    if (!args.GetString(0, &event_name) ||
-        event_name !=  std::string(keys::kOnSendHeadersEvent) + "/3") {
+    if (params.event_name != std::string(keys::kOnSendHeadersEvent) + "/3")
       continue;
-    }
 
-    base::ListValue* event_arg = NULL;
-    ASSERT_TRUE(args.GetList(1, &event_arg));
+    const base::ListValue& event_args = std::get<1>(message_tuple);
+    const base::DictionaryValue* event_arg_dict = nullptr;
+    ASSERT_TRUE(event_args.GetDictionary(0, &event_arg_dict));
 
-    base::DictionaryValue* event_arg_dict = NULL;
-    ASSERT_TRUE(event_arg->GetDictionary(0, &event_arg_dict));
-
-    base::ListValue* request_headers = NULL;
+    const base::ListValue* request_headers = nullptr;
     ASSERT_TRUE(event_arg_dict->GetList(keys::kRequestHeadersKey,
                                         &request_headers));
 
     net::HttpRequestHeaders observed_headers;
     for (size_t j = 0; j < request_headers->GetSize(); ++j) {
-      base::DictionaryValue* header = NULL;
+      const base::DictionaryValue* header = nullptr;
       ASSERT_TRUE(request_headers->GetDictionary(j, &header));
       std::string key;
       std::string value;
       ASSERT_TRUE(header->GetString(keys::kHeaderNameKey, &key));
       ASSERT_TRUE(header->GetString(keys::kHeaderValueKey, &value));
       observed_headers.SetHeader(key, value);
     }
 
     EXPECT_EQ(expected_headers.ToString(), observed_headers.ToString());
     ++num_headers_observed;
@@ skipping 1274 matching lines @@
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
 }  // namespace extensions