Rename extension_manifest_keys namespace to extensions::manifest_keys.

chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.cc

 // Copyright 2013 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/chromeos/input_method/component_extension_ime_manager_impl.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
-#include "chrome/common/extensions/extension_manifest_constants.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/common/manifest_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 
 namespace {
 
 struct WhitelistedComponentExtensionIME {
   const char* id;
   const char* path;
 } whitelisted_component_extension[] = {
@@ skipping 141 matching lines @@
   return is_initialized_;
 }
 
 // static
 bool ComponentExtensionIMEManagerImpl::ReadEngineComponent(
     const DictionaryValue& dict,
     ComponentExtensionEngine* out) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   DCHECK(out);
   std::string type;
-  if (!dict.GetString(extension_manifest_keys::kType, &type))
+  if (!dict.GetString(extensions::manifest_keys::kType, &type))
     return false;
   if (type != "ime")
     return false;
-  if (!dict.GetString(extension_manifest_keys::kId, &out->engine_id))
+  if (!dict.GetString(extensions::manifest_keys::kId, &out->engine_id))
     return false;
-  if (!dict.GetString(extension_manifest_keys::kName, &out->display_name))
+  if (!dict.GetString(extensions::manifest_keys::kName, &out->display_name))
     return false;
 
   std::set<std::string> languages;
   const base::Value* language_value = NULL;
-  if (dict.Get(extension_manifest_keys::kLanguage, &language_value)) {
+  if (dict.Get(extensions::manifest_keys::kLanguage, &language_value)) {
     if (language_value->GetType() == base::Value::TYPE_STRING) {
       std::string language_str;
       language_value->GetAsString(&language_str);
       languages.insert(language_str);
     } else if (language_value->GetType() == base::Value::TYPE_LIST) {
       const base::ListValue* language_list = NULL;
       language_value->GetAsList(&language_list);
       for (size_t j = 0; j < language_list->GetSize(); ++j) {
         std::string language_str;
         if (language_list->GetString(j, &language_str))
           languages.insert(language_str);
       }
     }
   }
   DCHECK(!languages.empty());
   out->language_codes.assign(languages.begin(), languages.end());
 
   const ListValue* layouts = NULL;
-  if (!dict.GetList(extension_manifest_keys::kLayouts, &layouts))
+  if (!dict.GetList(extensions::manifest_keys::kLayouts, &layouts))
     return false;
 
   for (size_t i = 0; i < layouts->GetSize(); ++i) {
     std::string buffer;
     if (layouts->GetString(i, &buffer))
       out->layouts.push_back(buffer);
   }
   return true;
 }
 
 // static
 bool ComponentExtensionIMEManagerImpl::ReadExtensionInfo(
     const DictionaryValue& manifest,
     const std::string& extension_id,
     ComponentExtensionIME* out) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  if (!manifest.GetString(extension_manifest_keys::kDescription,
+  if (!manifest.GetString(extensions::manifest_keys::kDescription,
                           &out->description))
     return false;
   std::string url_string;
-  if (!manifest.GetString(extension_manifest_keys::kOptionsPage, &url_string))
+  if (!manifest.GetString(extensions::manifest_keys::kOptionsPage, &url_string))
     return true;  // It's okay to return true on no option page case.
 
   GURL url = extensions::Extension::GetResourceURL(
       extensions::Extension::GetBaseURLFromExtensionId(extension_id),
       url_string);
   if (!url.is_valid())
     return false;
   out->options_page_url = url;
   return true;
 }
@@ skipping 22 matching lines @@
     if (!manifest.get())
       continue;
 
     if (!ReadExtensionInfo(*manifest.get(),
                            whitelisted_component_extension[i].id,
                            &component_ime))
       continue;
     component_ime.id = whitelisted_component_extension[i].id;
 
     const ListValue* component_list;
-    if (!manifest->GetList(extension_manifest_keys::kInputComponents,
+    if (!manifest->GetList(extensions::manifest_keys::kInputComponents,
                            &component_list))
       continue;
 
     for (size_t i = 0; i < component_list->GetSize(); ++i) {
       const DictionaryValue* dictionary;
       if (!component_list->GetDictionary(i, &dictionary))
         continue;
 
       ComponentExtensionEngine engine;
       ReadEngineComponent(*dictionary, &engine);
       component_ime.engines.push_back(engine);
     }
     out_imes->push_back(component_ime);
   }
 }
 
 void ComponentExtensionIMEManagerImpl::OnReadComponentExtensionsInfo(
     std::vector<ComponentExtensionIME>* result,
     const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(result);
   component_extension_list_ = *result;
   is_initialized_ = true;
   callback.Run();
 }
 
 }  // namespace chromeos