Extension loading extracts intents from Manifest data.

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"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "crypto/sha2.h"
+#include "chrome/browser/intents/web_intent_data.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/extension_sidebar_defaults.h"
 #include "chrome/common/extensions/extension_sidebar_utils.h"
@@ skipping 131 matching lines @@
       rank = 0;
       break;
 
     default:
       NOTREACHED() << "Need to add new extension locaton " << location;
   }
 
   CHECK(rank != kInvalidRank);
   return rank;
 }
-

[James Hawkins, 2011/09/19 18:51:40]

Keep this blank line.

[groby-ooo-7-16, 2011/09/19 21:33:59]

Done.

 }  // namespace
 
 const FilePath::CharType Extension::kManifestFilename[] =
     FILE_PATH_LITERAL("manifest.json");
 const FilePath::CharType Extension::kLocaleFolder[] =
     FILE_PATH_LITERAL("_locales");
 const FilePath::CharType Extension::kMessagesFilename[] =
     FILE_PATH_LITERAL("messages.json");
 
 #if defined(OS_WIN)
@@ skipping 968 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) {
+  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)) {
+    *error = errors::kInvalidIntents;
+    return false;
+  }
+
+  std::string value;
+  DictionaryValue::key_iterator iter(all_intents->begin_keys());

[James Hawkins, 2011/09/19 18:51:40]

iter must be defined in the scope of the for loop, indention be damned.

[groby-ooo-7-16, 2011/09/19 21:33:59]

Done.

+  for (; iter != all_intents->end_keys(); ++iter) {
+    WebIntentData intent;
+
+    DictionaryValue* one_intent = NULL;
+    if (!all_intents->GetDictionaryWithoutPathExpansion(*iter, &one_intent)) {
+      *error = errors::kInvalidIntent;
+      return false;
+    }
+    intent.action = UTF8ToUTF16(*iter);
+
+    // TODO(groby): Support an array of types

[James Hawkins, 2011/09/19 18:51:40]

Append period.

[groby-ooo-7-16, 2011/09/19 21:33:59]

Done.

+    if (one_intent->HasKey(keys::kIntentType)) {
+      if (!one_intent->GetString(keys::kIntentType, &intent.type)) {

[James Hawkins, 2011/09/19 18:51:40]

Save indentation: combine these two ifs.

Here and elsewhere.

[groby-ooo-7-16, 2011/09/19 21:33:59]

That's inconsistent with the entire rest of the file. I assume this style was
picked due to additional actions  in the inner else branch. Fixed it up for the
two statement where it made sense.

+        *error = errors::kInvalidIntentType;
+        return false;
+      }
+    }
+
+    if (one_intent->HasKey(keys::kIntentPath)) {
+      if (!one_intent->GetString(keys::kIntentPath, &value)) {
+        *error = errors::kInvalidIntentPath;
+        return false;
+      }
+      intent.service_url = GetResourceURL(value);
+    }
+
+    if (one_intent->HasKey(keys::kIntentTitle)) {
+      if (!one_intent->GetString(keys::kIntentTitle, &intent.title)) {
+        *error = errors::kInvalidIntentTitle;
+        return false;
+      }
+    }
+
+    if (one_intent->HasKey(keys::kIntentDisposition)) {
+      if (!one_intent->GetString(keys::kIntentDisposition, &value) ||
+          (value != values::kIntentDispositionWindow &&
+           value != values::kIntentDispositionInline)) {
+        *error = errors::kInvalidIntentDisposition;
+        return false;
+      }
+      if (value == values::kIntentDispositionInline)
+        intent.disposition = WebIntentData::DISPOSITION_INLINE;
+      else
+        intent.disposition = WebIntentData::DISPOSITION_WINDOW;
+    }
+
+    intents_.push_back(intent);
+  }
+  return true;
+}
+
+
 bool Extension::EnsureNotHybridApp(const DictionaryValue* manifest,
                                    std::string* error) {
   if (web_extent().is_empty())
     return true;
 
   for (DictionaryValue::key_iterator key = manifest->begin_keys();
        key != manifest->end_keys(); ++key) {
     if (!IsBaseCrxKey(*key) &&
         *key != keys::kApp &&
         *key != keys::kPermissions &&
@@ skipping 1090 matching lines @@
             }
             voice_data.event_types.insert(event_type);
           }
         }
 
         tts_voices_.push_back(voice_data);
       }
     }
   }
 
+  // Initialize web intents (optional).
+  if (!LoadWebIntents(source, error))
+    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;
     }
     if (value == values::kIncognitoSpanning) {
@@ skipping 612 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}