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

chrome/browser/extensions/extension_browser_event_router.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 "chrome/browser/extensions/extension_browser_event_router.h"
 
-#include "base/json_writer.h"
+#include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/extension_page_actions_module_constants.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 75 matching lines @@
   }
 }
 
 static void DispatchSimpleBrowserEvent(Profile* profile,
                                        const int window_id,
                                        const char* event_name) {
   ListValue args;
   args.Append(Value::CreateIntegerValue(window_id));
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(profile, event_name, json_args);
 }
 
 void ExtensionBrowserEventRouter::Init() {
   if (initialized_)
     return;
 
   BrowserList::AddObserver(this);
 
@@ skipping 13 matching lines @@
 }
 
 void ExtensionBrowserEventRouter::OnBrowserWindowReady(const Browser* browser) {
   ListValue args;
 
   DictionaryValue* window_dictionary = ExtensionTabUtil::CreateWindowValue(
       browser, false);
   args.Append(window_dictionary);
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(browser->profile(), events::kOnWindowCreated, json_args);
 }
 
 void ExtensionBrowserEventRouter::OnBrowserRemoving(const Browser* browser) {
   // Stop listening to TabStripModel events for this browser.
   browser->tabstrip_model()->RemoveObserver(this);
 
   registrar_.Remove(this, NotificationType::BROWSER_WINDOW_READY,
       Source<const Browser>(browser));
 
   DispatchSimpleBrowserEvent(browser->profile(),
                              ExtensionTabUtil::GetWindowId(browser),
                              events::kOnWindowRemoved);
 }
 
 void ExtensionBrowserEventRouter::OnBrowserSetLastActive(
     const Browser* browser) {
   DispatchSimpleBrowserEvent(browser->profile(),
                              ExtensionTabUtil::GetWindowId(browser),
                              events::kOnWindowFocusedChanged);
 }
 
 void ExtensionBrowserEventRouter::TabCreatedAt(TabContents* contents,
                                                 int index,
                                                 bool foreground) {
   ListValue args;
   args.Append(ExtensionTabUtil::CreateTabValue(contents));
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabCreated, json_args);
 
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(&contents->controller()));
 
   // Observing TAB_CONTENTS_DESTROYED is necessary because it's
   // possible for tabs to be created, detached and then destroyed without
   // ever having been re-attached and closed. This happens in the case of
   // a devtools TabContents that is opened in window, docked, then closed.
@@ skipping 17 matching lines @@
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kNewWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tab_keys::kNewPositionKey, Value::CreateIntegerValue(
       index));
   args.Append(object_args);
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabAttached, json_args);
 }
 
 void ExtensionBrowserEventRouter::TabDetachedAt(TabContents* contents,
                                                 int index) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   if (tab_entries_.find(tab_id) == tab_entries_.end()) {
     // The tab was removed. Don't send detach event.
     return;
   }
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kOldWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tab_keys::kOldPositionKey, Value::CreateIntegerValue(
       index));
   args.Append(object_args);
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabDetached, json_args);
 }
 
 void ExtensionBrowserEventRouter::TabClosingAt(TabContents* contents,
                                                int index) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
 
   ListValue args;
   args.Append(Value::CreateIntegerValue(tab_id));
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabRemoved, json_args);
 
   int removed_count = tab_entries_.erase(tab_id);
   DCHECK_GT(removed_count, 0);
 
   registrar_.Remove(this, NotificationType::NAV_ENTRY_COMMITTED,
       Source<NavigationController>(&contents->controller()));
   registrar_.Remove(this, NotificationType::TAB_CONTENTS_DESTROYED,
       Source<TabContents>(contents));
 }
 
 void ExtensionBrowserEventRouter::TabSelectedAt(TabContents* old_contents,
                                                 TabContents* new_contents,
                                                 int index,
                                                 bool user_gesture) {
   ListValue args;
   args.Append(Value::CreateIntegerValue(
       ExtensionTabUtil::GetTabId(new_contents)));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(new_contents)));
   args.Append(object_args);
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(new_contents->profile(), events::kOnTabSelectionChanged,
                 json_args);
 }
 
 void ExtensionBrowserEventRouter::TabMoved(TabContents* contents,
                                            int from_index,
                                            int to_index,
                                            bool pinned_state_changed) {
   ListValue args;
   args.Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tab_keys::kFromIndexKey, Value::CreateIntegerValue(
       from_index));
   object_args->Set(tab_keys::kToIndexKey, Value::CreateIntegerValue(
       to_index));
   args.Append(object_args);
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   DispatchEvent(contents->profile(), events::kOnTabMoved, json_args);
 }
 
 void ExtensionBrowserEventRouter::TabUpdated(TabContents* contents,
                                              bool did_navigate) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   std::map<int, TabEntry>::iterator i = tab_entries_.find(tab_id);
   DCHECK(tab_entries_.end() != i);
   TabEntry& entry = i->second;
 
   DictionaryValue* changed_properties = NULL;
   if (did_navigate)
     changed_properties = entry.DidNavigate(contents);
   else
     changed_properties = entry.UpdateLoadState(contents);
 
   if (changed_properties) {
     // The state of the tab (as seen from the extension point of view) has
     // changed.  Send a notification to the extension.
     ListValue args;
     args.Append(Value::CreateIntegerValue(tab_id));
     args.Append(changed_properties);
 
     std::string json_args;
-    JSONWriter::Write(&args, false, &json_args);
+    base::JSONWriter::Write(&args, false, &json_args);
 
     DispatchEvent(contents->profile(), events::kOnTabUpdated, json_args);
   }
 }
 
 void ExtensionBrowserEventRouter::Observe(NotificationType type,
                                           const NotificationSource& source,
                                           const NotificationDetails& details) {
   if (type == NotificationType::NAV_ENTRY_COMMITTED) {
     NavigationController* source_controller =
@@ skipping 32 matching lines @@
   ListValue args;
   args.Append(Value::CreateStringValue(page_action_id));
 
   DictionaryValue* data = new DictionaryValue();
   data->Set(tab_keys::kTabIdKey, Value::CreateIntegerValue(tab_id));
   data->Set(tab_keys::kTabUrlKey, Value::CreateStringValue(url));
   data->Set(page_action_keys::kButtonKey, Value::CreateIntegerValue(button));
   args.Append(data);
 
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   std::string event_name = std::string("pageAction/") + extension_id;
   DispatchEvent(profile, event_name.c_str(), json_args);
 }
 
 void ExtensionBrowserEventRouter::BrowserActionExecuted(
     Profile* profile, const std::string& extension_id, Browser* browser) {
   TabContents* tab_contents = NULL;
   int tab_id = 0;
   if (!ExtensionTabUtil::GetDefaultTab(browser, &tab_contents, &tab_id))
     return;
 
   ListValue args;
   args.Append(ExtensionTabUtil::CreateTabValue(tab_contents));
   std::string json_args;
-  JSONWriter::Write(&args, false, &json_args);
+  base::JSONWriter::Write(&args, false, &json_args);
 
   std::string event_name = std::string("browserAction/") + extension_id;
   DispatchEvent(profile, event_name.c_str(), json_args);
 }