Validation of extension api callback and event parameters in DEBUG

chrome/browser/extensions/extension_uitest.cc

 // Copyright (c) 2009 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 "base/command_line.h"
 #include "base/gfx/rect.h"
 #include "base/json_reader.h"
 #include "base/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/automation/extension_automation_constants.h"
+#include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/automation/automation_messages.h"
 #include "chrome/test/automation/automation_proxy_uitest.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "googleurl/src/gurl.h"
 
 namespace {
 
@@ skipping 197 matching lines @@
     ASSERT_TRUE(request_dict->GetString(keys::kAutomationNameKey,
                                         &function_name));
     int request_id = -2;
     EXPECT_TRUE(request_dict->GetInteger(keys::kAutomationRequestIdKey,
                                          &request_id));
     bool has_callback = false;
     EXPECT_TRUE(request_dict->GetBoolean(keys::kAutomationHasCallbackKey,
                                          &has_callback));
 
     if (messages_received_ == 1) {
-      EXPECT_EQ(function_name, "windows.getLastFocused");
+      EXPECT_EQ(function_name, "tabs.getSelected");
       EXPECT_GE(request_id, 0);
       EXPECT_TRUE(has_callback);
 
       DictionaryValue response_dict;
       EXPECT_TRUE(response_dict.SetInteger(keys::kAutomationRequestIdKey,
                                            request_id));
-      EXPECT_TRUE(response_dict.SetString(keys::kAutomationResponseKey, "42"));
+      DictionaryValue tab_dict;
+      EXPECT_TRUE(tab_dict.SetInteger(extension_tabs_module_constants::kIdKey,
+                                      42));
+      EXPECT_TRUE(tab_dict.SetInteger(
+          extension_tabs_module_constants::kIndexKey, 1));
+      EXPECT_TRUE(tab_dict.SetInteger(
+          extension_tabs_module_constants::kWindowIdKey, 1));
+      EXPECT_TRUE(tab_dict.SetBoolean(
+          extension_tabs_module_constants::kSelectedKey, true));
+      EXPECT_TRUE(tab_dict.SetString(
+          extension_tabs_module_constants::kUrlKey, "http://www.google.com"));
+
+      std::string tab_json;
+      JSONWriter::Write(&tab_dict, false, &tab_json);
+
+      EXPECT_TRUE(response_dict.SetString(keys::kAutomationResponseKey, tab_json));
 
       std::string response_json;
       JSONWriter::Write(&response_dict, false, &response_json);
 
       tab_->HandleMessageFromExternalHost(
           response_json,
           keys::kAutomationOrigin,
           keys::kAutomationResponseTarget);
     } else if (messages_received_ == 2) {
       EXPECT_EQ(function_name, "tabs.remove");
@@ skipping 54 matching lines @@
         tab_(NULL) {
   }
 
   // Must set before initiating test.
   TabProxy* tab_;
 
   // Counts the number of times we got a given event.
   std::map<std::string, int> event_count_;
 
   // Array containing the names of the events to fire to the extension.
-  static const char* event_names_[];
+  static const char* events_[];
 
  protected:
   // Process a message received from the test extension.
   virtual void HandleMessageFromChrome();
 
   // Fire an event of the given name to the test extension.
   void FireEvent(const char* event_name);
 };
 
-const char* BrowserEventAutomationProxy::event_names_[] = {
+const char* BrowserEventAutomationProxy::events_[] = {
   // Window events.
-  "windows.onCreated",
-  "windows.onRemoved",
-  "windows.onFocusChanged",
-
+  "[\"windows.onCreated\", \"[42]\"]",
+  
+  "[\"windows.onRemoved\", \"[42]\"]",
+  
+  "[\"windows.onFocusChanged\", \"[42]\"]",
+  
   // Tab events.
-  "tabs.onCreated",
-  "tabs.onUpdated",
-  "tabs.onMoved",
-  "tabs.onSelectionChanged",
-  "tabs.onAttached",
-  "tabs.onDetached",
-  "tabs.onRemoved",
+  "[\"tabs.onCreated\", \"[{'id\':42,'index':1,'windowId':1,"
+      "'selected':true,'url':'http://www.google.com'}]\"]",
+  
+  "[\"tabs.onUpdated\", \"[42, {'status': 'complete',"
+      "'url':'http://www.google.com'}]\"]",
+  
+  "[\"tabs.onMoved\", \"[42, {'windowId':1,'fromIndex':1,'toIndex':2}]\"]",
+  
+  "[\"tabs.onSelectionChanged\", \"[42, {'windowId':1}]\"]",
+  
+  "[\"tabs.onAttached\", \"[42, {'newWindowId':1,'newPosition':1}]\"]",
+  
+  "[\"tabs.onDetached\", \"[43, {'oldWindowId':1,'oldPosition':1}]\"]",
+  
+  "[\"tabs.onRemoved\", \"[43]\"]",
 
   // Bookmark events.
-  "bookmarks.onAdded",
-  "bookmarks.onRemoved",
-  "bookmarks.onChanged",
-  "bookmarks.onMoved",
-  "bookmarks.onChildrenReordered",
+  "[\"bookmarks.onAdded\", \"['42', {'id':'42','title':'foo',}]\"]",
+  
+  "[\"bookmarks.onRemoved\", \"['42', {'parentId':'2','index':1}]\"]",
+  
+  "[\"bookmarks.onChanged\", \"['42', {'title':'foo'}]\"]",
+  
+  "[\"bookmarks.onMoved\", \"['42', {'parentId':'2','index':1,"
+      "'oldParentId':'3','oldIndex':2}]\"]",
+  
+  "[\"bookmarks.onChildrenReordered\", \"['32', ['1', '2', '3']]\"]"
 };
 
 void BrowserEventAutomationProxy::HandleMessageFromChrome() {
   namespace keys = extension_automation_constants;
   ASSERT_TRUE(tab_ != NULL);
 
   std::string message(message());
   std::string origin(origin());
   std::string target(target());
 
@@ skipping 18 matching lines @@
     // TEST_F(BrowserEventExtensionTest, RunTest) to understand where the
     // extension Id comes from.
     tab_->HandleMessageFromExternalHost(
         "{\"rqid\":0, \"extid\": \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\","
         " \"connid\": 1}",
         keys::kAutomationOrigin,
         keys::kAutomationPortRequestTarget);
   } else if (target == keys::kAutomationPortResponseTarget) {
     // This is a response to the open channel request.  This means we know
     // that the port is ready to send us messages.  Fire all the events now.
-    for (int i = 0; i < arraysize(event_names_); ++i) {
-      FireEvent(event_names_[i]);
+    for (int i = 0; i < arraysize(events_); ++i) {
+      FireEvent(events_[i]);
     }
   } else if (target == keys::kAutomationPortRequestTarget) {
     // This is the test extension calling us back.  Make sure its telling
     // us that it received an event.  We do this by checking to see if the
     // message is a simple string of one of the event names that is fired.
     //
     // There is a special message "ACK" which means that the extension
     // received the port connection.  This is not an event response and
     // should happen before all events.
     scoped_ptr<Value> message_value(JSONReader::Read(message, false));
     ASSERT_TRUE(message_value->IsType(Value::TYPE_DICTIONARY));
     DictionaryValue* message_dict =
         reinterpret_cast<DictionaryValue*>(message_value.get());
 
     std::string event_name;
     ASSERT_TRUE(message_dict->GetString(L"data", &event_name));
     if (event_name == "\"ACK\"") {
       ASSERT_EQ(0, event_count_.size());
     } else {
       ++event_count_[event_name];
     }
   }
 }
 
-void BrowserEventAutomationProxy::FireEvent(const char* event_name) {
+void BrowserEventAutomationProxy::FireEvent(const char* event) {
   namespace keys = extension_automation_constants;
 
   // Build the event message to send to the extension.  The only important
   // part is the name, as the payload is not used by the test extension.
   std::string message;
-  message += "[\"";
-  message += event_name;
-  message += "\", \"[]\"]";
+  message += event;
 
   tab_->HandleMessageFromExternalHost(
       message,
       keys::kAutomationOrigin,
       keys::kAutomationBrowserEventRequestTarget);
 }
 
 class BrowserEventExtensionTest
     : public ExtensionUITest<
                  CustomAutomationProxyTest<BrowserEventAutomationProxy>> {
@@ skipping 31 matching lines @@
   Extension::ResetGeneratedIdCounter();
   TestWithURL(GURL(
       "chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/test.html"));
   BrowserEventAutomationProxy* proxy =
       static_cast<BrowserEventAutomationProxy*>(automation());
 
   // If this assert hits and the actual size is 0 then you need to look at:
   // src\chrome\test\data\extensions\uitest\event_sink\test.html and see if
   // all the events we are attaching to are valid. Also compare the list against
   // the event_names_ string array above.
-  EXPECT_EQ(arraysize(BrowserEventAutomationProxy::event_names_),
+  EXPECT_EQ(arraysize(BrowserEventAutomationProxy::events_),
             proxy->event_count_.size());
   for (std::map<std::string, int>::iterator i = proxy->event_count_.begin();
       i != proxy->event_count_.end(); ++i) {
     const std::pair<std::string, int>& value = *i;
     ASSERT_EQ(1, value.second);
   }
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace