Implement extension:// protocol.

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2006-2008 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/extensions_service.h"
 
 #include "base/file_util.h"
 #include "base/values.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/json_value_serializer.h"
+#include "chrome/common/notification_service.h"
 
 // ExtensionsService
 
 const FilePath::CharType* ExtensionsService::kInstallDirectoryName =
     FILE_PATH_LITERAL("Extensions");
 
 ExtensionsService::ExtensionsService(const FilePath& profile_directory)
     : message_loop_(MessageLoop::current()),
       backend_(new ExtensionsServiceBackend),
       install_directory_(profile_directory.Append(kInstallDirectoryName)) {
@@ skipping 21 matching lines @@
 }
 
 MessageLoop* ExtensionsService::GetMessageLoop() {
   return message_loop_;
 }
 
 void ExtensionsService::OnExtensionsLoadedFromDirectory(
     ExtensionList* new_extensions) {
   extensions_.insert(extensions_.end(), new_extensions->begin(),
                      new_extensions->end());
+
+  NotificationService::current()->Notify(NOTIFY_EXTENSIONS_LOADED,
+      NotificationService::AllSources(),
+      Details<ExtensionList>(new_extensions));
+
   delete new_extensions;
-
-  // TODO(aa): Notify extensions are loaded.
 }
 
 void ExtensionsService::OnExtensionLoadError(const std::string& error) {
   // TODO(aa): Print the error message out somewhere better. I think we are
   // going to need some sort of 'extension inspector'.
   LOG(WARNING) << error;
 }
 
 
 // ExtensionsServicesBackend
@@ skipping 25 matching lines @@
       continue;
     }
 
     scoped_ptr<Value> scoped_root(root);
     if (!root->IsType(Value::TYPE_DICTIONARY)) {
       ReportExtensionLoadError(frontend.get(), child_path.ToWStringHack(),
                                Extension::kInvalidManifestError);
       continue;
     }
 
-    scoped_ptr<Extension> extension(new Extension());
+    scoped_ptr<Extension> extension(new Extension(child_path));
     if (!extension->InitFromValue(*static_cast<DictionaryValue*>(root),
                                   &error)) {
       ReportExtensionLoadError(frontend.get(), child_path.ToWStringHack(),
                                error);
       continue;
     }
 
     extensions->push_back(extension.release());
   }
 
@@ skipping 11 matching lines @@
       message));
 }
 
 void ExtensionsServiceBackend::ReportExtensionsLoaded(
     ExtensionsServiceFrontendInterface *frontend, ExtensionList* extensions) {
   frontend->GetMessageLoop()->PostTask(FROM_HERE, NewRunnableMethod(
       frontend,
       &ExtensionsServiceFrontendInterface::OnExtensionsLoadedFromDirectory,
       extensions));
 }