Implemented the rest of loading/parsing logic for extension i18n:...

chrome/common/extensions/extension.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 #define CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "base/version.h"
+#include "chrome/browser/extensions/extension_message_handler.h"
+#include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/common/extensions/user_script.h"
-#include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/page_action.h"
 #include "googleurl/src/gurl.h"
 
 // Represents a Chrome extension.
 class Extension {
  public:
   // What an extension was loaded from.
   enum Location {
     INVALID,
@@ skipping 155 matching lines @@
   const FilePath& path() const { return path_; }
   void set_path(const FilePath& path) { path_ = path; }
   const GURL& url() const { return extension_url_; }
   const Location location() const { return location_; }
   void set_location(Location location) { location_ = location; }
   const std::string& id() const { return id_; }
   const Version* version() const { return version_.get(); }
   // String representation of the version number.
   const std::string VersionString() const;
   const std::string& name() const { return name_; }
+  // Sets name to a new value in case it got updated during l10n process.
+  void set_name(const std::string& name) { name_ = name; }
   const std::string& public_key() const { return public_key_; }
   const std::string& description() const { return description_; }
+  // Sets description to a new value in case it got updated during l10n process.
+  void set_description(const std::string& description) {
+    description_ = description;
+  }
   const UserScriptList& content_scripts() const { return content_scripts_; }
   const PageActionMap& page_actions() const { return page_actions_; }
   const std::vector<PrivacyBlacklistInfo>& privacy_blacklists() const {
     return privacy_blacklists_;
   }
   const std::vector<PluginInfo>& plugins() const { return plugins_; }
   const GURL& background_url() const { return background_url_; }
   const std::vector<ToolstripInfo>& toolstrips() const { return toolstrips_; }
   const std::vector<URLPattern>& host_permissions() const {
     return host_permissions_;
@@ skipping 43 matching lines @@
   void AddSupportedLocale(const std::string& supported_locale) {
     supported_locales_.insert(supported_locale);
   }
 
   // Getter/setter for a default_locale_.
   const std::string& default_locale() const { return default_locale_; }
   void set_default_locale(const std::string& default_locale) {
     default_locale_ = default_locale;
   }
 
+  // Getter/setter for application_locale.
+  const std::string& application_locale() const { return application_locale_; }
+  void set_application_locale(const std::string& application_locale) {
+    application_locale_ = application_locale;

[Aaron Boodman, 2009/08/31 21:42:55]

Why do we need to store a duplicate copy of the application locale here? It
seems like we can get this from wherever it is stored when needed.

+  }
+
+  // Getter/setter for l10n message handler.
+  const ExtensionMessageHandler* message_handler() const {
+    return message_handler_.get();
+  }
+  void set_message_handler(ExtensionMessageHandler* message_handler) {
+    message_handler_.reset(message_handler);
+  }
+
   // Runtime data:
   // Put dynamic data about the state of a running extension below.
 
   // Whether the background page, if any, is ready. We don't load other
   // components until then. If there is no background page, we consider it to
   // be ready.
   bool GetBackgroundPageReady();
   void SetBackgroundPageReady();
 
  private:
@@ skipping 100 matching lines @@
 
   // A copy of the manifest that this extension was created from.
   scoped_ptr<DictionaryValue> manifest_value_;
 
     // List of all locales extension supports.
   std::set<std::string> supported_locales_;
 
   // Default locale, used for fallback.
   std::string default_locale_;
 
+  // Application locale (from l10n_util::GetApplicationLocale()).
+  std::string application_locale_;
+
+  // Handles the l10n messages replacement and parsing.
+  scoped_ptr<ExtensionMessageHandler> message_handler_;
+
   // Runtime data:
 
   // True if the background page is ready.
   bool background_page_ready_;
 
   FRIEND_TEST(ExtensionTest, LoadPageActionHelper);
 
   DISALLOW_COPY_AND_ASSIGN(Extension);
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_