chrome: Use base::MessageLoop. (Part 3)

chrome/browser/extensions/event_router.cc

 // Copyright (c) 2012 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/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 624 matching lines @@
       std::set<std::string> registered_events =
           prefs->GetRegisteredEvents(extension->id());
       listeners_.LoadUnfilteredLazyListeners(extension->id(),
                                              registered_events);
       const DictionaryValue* filtered_events =
           prefs->GetFilteredEvents(extension->id());
       if (filtered_events)
         listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
 
       if (dispatch_chrome_updated_event_) {
-        MessageLoop::current()->PostTask(FROM_HERE,
-            base::Bind(&DispatchOnInstalledEvent, profile_, extension->id(),
-                       Version(), true));
+        base::MessageLoop::current()->PostTask(
+            FROM_HERE,
+            base::Bind(&DispatchOnInstalledEvent,

[brettw, 2013/04/28 04:26:27]

I'd keep the old way, same below.

+                       profile_,
+                       extension->id(),
+                       Version(),
+                       true));
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       // Remove all registered lazy listeners from our cache.
       UnloadedExtensionInfo* unloaded =
           content::Details<UnloadedExtensionInfo>(details).ptr();
       listeners_.RemoveLazyListenersForExtension(unloaded->extension->id());
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
       // Dispatch the onInstalled event.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
 
       // Get the previous version, if this is an upgrade.
       ExtensionService* service =
           ExtensionSystem::Get(profile_)->extension_service();
       const Extension* old = service->GetExtensionById(extension->id(), true);
       Version old_version;
       if (old)
         old_version = *old->version();
 
-      MessageLoop::current()->PostTask(FROM_HERE,
-          base::Bind(&DispatchOnInstalledEvent, profile_, extension->id(),
-                     old_version, false));
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&DispatchOnInstalledEvent,
+                     profile_,
+                     extension->id(),
+                     old_version,
+                     false));
       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
 Event::Event(const std::string& event_name,
              scoped_ptr<base::ListValue> event_args)
@@ skipping 41 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions