Move the json-related files into a separate json directory. This hopefully al...

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/json/json_reader.h"
+#include "base/json/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"
@@ skipping 97 matching lines @@
       "chrome-extension://pmgpglkggjdpkpghhdmbdhababjpcohk/test.html"));
   AutomationProxyForExternalTab* proxy =
       static_cast<AutomationProxyForExternalTab*>(automation());
   ASSERT_GT(proxy->messages_received(), 0);
 
   // Using EXPECT_TRUE rather than EXPECT_EQ as the compiler (VC++) isn't
   // finding the right match for EqHelper.
   EXPECT_TRUE(proxy->origin() == keys::kAutomationOrigin);
   EXPECT_TRUE(proxy->target() == keys::kAutomationRequestTarget);
 
-  scoped_ptr<Value> message_value(JSONReader::Read(proxy->message(), false));
+  scoped_ptr<Value> message_value(base::JSONReader::Read(proxy->message(),
+                                                         false));
   ASSERT_TRUE(message_value->IsType(Value::TYPE_DICTIONARY));
   DictionaryValue* message_dict =
       reinterpret_cast<DictionaryValue*>(message_value.get());
   std::string result;
   ASSERT_TRUE(message_dict->GetString(keys::kAutomationNameKey, &result));
   EXPECT_EQ(result, "tabs.remove");
 
   result = "";
   ASSERT_TRUE(message_dict->GetString(keys::kAutomationArgsKey, &result));
   EXPECT_NE(result, "");
@@ skipping 64 matching lines @@
     namespace keys = extension_automation_constants;
 
     ASSERT_TRUE(tab_ != NULL);
     ASSERT_TRUE(messages_received_ == 1 || messages_received_ == 2);
 
     // Using EXPECT_TRUE rather than EXPECT_EQ as the compiler (VC++) isn't
     // finding the right match for EqHelper.
     EXPECT_TRUE(origin_ == keys::kAutomationOrigin);
     EXPECT_TRUE(target_ == keys::kAutomationRequestTarget);
 
-    scoped_ptr<Value> message_value(JSONReader::Read(message_, false));
+    scoped_ptr<Value> message_value(base::JSONReader::Read(message_, false));
     ASSERT_TRUE(message_value->IsType(Value::TYPE_DICTIONARY));
     DictionaryValue* request_dict =
         static_cast<DictionaryValue*>(message_value.get());
     std::string function_name;
     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;
@@ skipping 14 matching lines @@
       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);
+      base::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);
+      base::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");
       EXPECT_FALSE(has_callback);
 
       std::string args;
@@ skipping 116 matching lines @@
   std::string origin(origin());
   std::string target(target());
 
   ASSERT_TRUE(message.length() > 0);
   ASSERT_STREQ(keys::kAutomationOrigin, origin.c_str());
 
   if (target == keys::kAutomationRequestTarget) {
     // This should be a request for the current window.  We don't need to
     // respond, as this is used only as an indication that the extension
     // page is now loaded.
-    scoped_ptr<Value> message_value(JSONReader::Read(message, false));
+    scoped_ptr<Value> message_value(base::JSONReader::Read(message, false));
     ASSERT_TRUE(message_value->IsType(Value::TYPE_DICTIONARY));
     DictionaryValue* message_dict =
         reinterpret_cast<DictionaryValue*>(message_value.get());
 
     std::string name;
     ASSERT_TRUE(message_dict->GetString(keys::kAutomationNameKey, &name));
     ASSERT_STREQ(name.c_str(), "windows.getCurrent");
 
     // Send an OpenChannelToExtension message to chrome. Note: the JSON
     // reader expects quoted property keys.  See the comment in
@@ skipping 11 matching lines @@
       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));
+    scoped_ptr<Value> message_value(base::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];
@@ skipping 56 matching lines @@
             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