Rewrite std::string("") to std::string(), Linux edition.

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 101 matching lines @@
     if (!extension_service) {
       LOG(WARNING) << "ExtensionService does not seem to be available "
                    << "(this may be normal for unit tests)";
     } else {
       const Extension* extension =
           extension_service->extensions()->GetByID(extension_id);
       if (!extension) {
         LOG(WARNING) << "Extension " << extension_id << " not found!";
       } else {
         extensions::ActivityLog::GetInstance(profile)->LogEventAction(
-            extension, event_name, event_args.get(), "");
+            extension, event_name, event_args.get(), std::string());
       }
     }
   }
 }
 
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* profile_id,
                                            const std::string& extension_id,
                                            const std::string& event_name,
@@ skipping 103 matching lines @@
   if (observer != observers_.end())
     observer->second->OnListenerAdded(details);
 
   const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
       extension_service()->GetExtensionById(listener->extension_id,
                                             ExtensionService::INCLUDE_ENABLED);
   if (extension) {
     scoped_ptr<ListValue> args(new ListValue());
     if (listener->filter)
       args->Append(listener->filter->DeepCopy());
-    activity_log_->LogAPIAction(extension,
-                                event_name + ".addListener",
-                                args.get(),
-                                "");
+    activity_log_->LogAPIAction(
+        extension, event_name + ".addListener", args.get(), std::string());
   }
 }
 
 void EventRouter::OnListenerRemoved(const EventListener* listener) {
   const std::string& event_name = listener->event_name;
   const EventListenerInfo details(event_name, listener->extension_id);
   ObserverMap::iterator observer = observers_.find(event_name);
   if (observer != observers_.end())
     observer->second->OnListenerRemoved(details);
 
   void* profile =
       listener->process
           ? Profile::FromBrowserContext(listener->process->GetBrowserContext())
           : NULL;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&NotifyEventListenerRemovedOnIOThread,
                  profile, listener->extension_id, event_name));
 
   const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
       extension_service()->GetExtensionById(listener->extension_id,
                                             ExtensionService::INCLUDE_ENABLED);
   if (extension) {
     scoped_ptr<ListValue> args(new ListValue());
-    activity_log_->LogAPIAction(extension,
-                                event_name + ".removeListener",
-                                args.get(),
-                                "");
+    activity_log_->LogAPIAction(
+        extension, event_name + ".removeListener", args.get(), std::string());
   }
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   scoped_ptr<EventListener> listener(new EventListener(
       event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
   bool is_new = listeners_.AddListener(listener.Pass());
 
   if (is_new) {
@@ skipping 89 matching lines @@
 
   for (std::set<ListenerProcess>::const_iterator listener = listeners.begin();
        listener != listeners.end(); ++listener) {
     if (listener->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 void EventRouter::BroadcastEvent(scoped_ptr<Event> event) {
-  DispatchEventImpl("", linked_ptr<Event>(event.release()));
+  DispatchEventImpl(std::string(), linked_ptr<Event>(event.release()));
 }
 
 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
                                            scoped_ptr<Event> event) {
   DCHECK(!extension_id.empty());
   DispatchEventImpl(extension_id, linked_ptr<Event>(event.release()));
 }
 
 void EventRouter::DispatchEventImpl(const std::string& restrict_to_extension_id,
                                     const linked_ptr<Event>& event) {
@@ skipping 322 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