Add webkit_glue namespace. Improve some variable and test names.

chrome/common/extensions/extension.cc

 // Copyright (c) 2011 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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 1148 matching lines @@
     if (isolation_string == values::kIsolatedStorage) {
       is_storage_isolated_ = true;
     } else {
       LOG(WARNING) << "Did not recognize isolation type: "
                    << isolation_string;
     }
   }
   return true;
 }
 
-bool Extension::LoadWebIntents(const base::DictionaryValue& manifest,
-                               std::string* error) {
+bool Extension::LoadWebIntentsServices(const base::DictionaryValue& manifest,
+                                       std::string* error) {
   DCHECK(error);
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableWebIntents))
     return true;
 
   if (!manifest.HasKey(keys::kIntents))
     return true;
 
-  DictionaryValue* all_intents = NULL;
-  if (!manifest.GetDictionary(keys::kIntents, &all_intents)) {
+  DictionaryValue* all_services = NULL;
+  if (!manifest.GetDictionary(keys::kIntents, &all_services)) {
     *error = errors::kInvalidIntents;
     return false;
   }
 
   std::string value;
-  for (DictionaryValue::key_iterator iter(all_intents->begin_keys());
-       iter != all_intents->end_keys(); ++iter) {
-    WebIntentServiceData intent;
+  for (DictionaryValue::key_iterator iter(all_services->begin_keys());
+       iter != all_services->end_keys(); ++iter) {
+    webkit_glue::WebIntentServiceData service;
 
-    DictionaryValue* one_intent = NULL;
-    if (!all_intents->GetDictionaryWithoutPathExpansion(*iter, &one_intent)) {
+    DictionaryValue* one_service = NULL;
+    if (!all_services->GetDictionaryWithoutPathExpansion(*iter, &one_service)) {
       *error = errors::kInvalidIntent;
       return false;
     }
-    intent.action = UTF8ToUTF16(*iter);
+    service.action = UTF8ToUTF16(*iter);
 
     // TODO(groby): Support an array of types.
-    if (one_intent->HasKey(keys::kIntentType) &&
-        !one_intent->GetString(keys::kIntentType, &intent.type)) {
+    if (one_service->HasKey(keys::kIntentType) &&
+        !one_service->GetString(keys::kIntentType, &service.type)) {
       *error = errors::kInvalidIntentType;
       return false;
     }
 
-    if (one_intent->HasKey(keys::kIntentPath)) {
-      if (!one_intent->GetString(keys::kIntentPath, &value)) {
+    if (one_service->HasKey(keys::kIntentPath)) {
+      if (!one_service->GetString(keys::kIntentPath, &value)) {
         *error = errors::kInvalidIntentPath;
         return false;
       }
-      intent.service_url = GetResourceURL(value);
+      service.service_url = GetResourceURL(value);
     }
 
-    if (one_intent->HasKey(keys::kIntentTitle) &&
-        !one_intent->GetString(keys::kIntentTitle, &intent.title)) {
+    if (one_service->HasKey(keys::kIntentTitle) &&
+        !one_service->GetString(keys::kIntentTitle, &service.title)) {
       *error = errors::kInvalidIntentTitle;
       return false;
     }
 
-    if (one_intent->HasKey(keys::kIntentDisposition)) {
-      if (!one_intent->GetString(keys::kIntentDisposition, &value) ||
+    if (one_service->HasKey(keys::kIntentDisposition)) {
+      if (!one_service->GetString(keys::kIntentDisposition, &value) ||
           (value != values::kIntentDispositionWindow &&
            value != values::kIntentDispositionInline)) {
         *error = errors::kInvalidIntentDisposition;
         return false;
       }
-      if (value == values::kIntentDispositionInline)
-        intent.disposition = WebIntentServiceData::DISPOSITION_INLINE;
-      else
-        intent.disposition = WebIntentServiceData::DISPOSITION_WINDOW;
+      if (value == values::kIntentDispositionInline) {
+        service.disposition =
+            webkit_glue::WebIntentServiceData::DISPOSITION_INLINE;
+      } else {
+        service.disposition =
+            webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW;
+      }
     }
 
-    intents_.push_back(intent);
+    intents_services_.push_back(service);
   }
   return true;
 }
 
 
 bool Extension::EnsureNotHybridApp(const DictionaryValue* manifest,
                                    std::string* error) {
   if (web_extent().is_empty())
     return true;
 
@@ skipping 1067 matching lines @@
             voice_data.event_types.insert(event_type);
           }
         }
 
         tts_voices_.push_back(voice_data);
       }
     }
   }
 
   // Initialize web intents (optional).
-  if (!LoadWebIntents(source, error))
+  if (!LoadWebIntentsServices(source, error))

[groby-ooo-7-16, 2011/10/31 20:53:37]

nit: Should that be LoadWebIntentServices (i.e. singular intent, plural
services)?

[Greg Billock, 2011/11/01 17:11:17]

Yeah, that sounds better.

     return false;
 
   // Initialize incognito behavior. Apps default to split mode, extensions
   // default to spanning.
   incognito_split_mode_ = is_app();
   if (source.HasKey(keys::kIncognito)) {
     std::string value;
     if (!source.GetString(keys::kIncognito, &value)) {
       *error = errors::kInvalidIncognitoBehavior;
       return false;
@@ skipping 658 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}