Fix device_event_log component build, make NonThreadSafe (Take 2)

components/device_event_log/device_event_log.h

 // Copyright 2014 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 COMPONENTS_DEVICE_EVENT_LOG_DEVICE_EVENT_LOG_H_
 #define COMPONENTS_DEVICE_EVENT_LOG_DEVICE_EVENT_LOG_H_
 
 #include <cstring>
 #include <sstream>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/timer/elapsed_timer.h"
+#include "components/device_event_log/device_event_log_export.h"
 
 // These macros can be used to log device related events.
+//
+// NOTE: If these macros are called from a thread other than the thread that
+// device_event_log::Initialize() was called from (i.e. the UI thread), a task
+// will be posted to the UI thread to log the event.
+//
 // The following values should be used for |level| in these macros:
 //  ERROR Unexpected events, or device level failures. Use sparingly.
 //  USER  Events initiated directly by a user (or Chrome) action.
 //  EVENT Default event type.
 //  DEBUG Debugging details that are usually not interesting.
+//
 // Examples:
 //  NET_LOG(EVENT) << "NetworkState Changed " << name << ": " << state;
 //  POWER_LOG(USER) << "Suspend requested";
 
 #define NET_LOG(level)                             \
   DEVICE_LOG(::device_event_log::LOG_TYPE_NETWORK, \
              ::device_event_log::LOG_LEVEL_##level)
 #define POWER_LOG(level)                         \
   DEVICE_LOG(::device_event_log::LOG_TYPE_POWER, \
              ::device_event_log::LOG_LEVEL_##level)
@@ skipping 62 matching lines @@
   LOG_LEVEL_USER = 1,
   LOG_LEVEL_EVENT = 2,
   LOG_LEVEL_DEBUG = 3
 };
 
 // Used to specify which order to output event entries in GetAsString.
 enum StringOrder { OLDEST_FIRST, NEWEST_FIRST };
 
 // Initializes / shuts down device event logging. If |max_entries| = 0 the
 // default value will be used.
-void Initialize(size_t max_entries);
-void Shutdown();
+void DEVICE_EVENT_LOG_EXPORT Initialize(size_t max_entries);
+bool DEVICE_EVENT_LOG_EXPORT IsInitialized();
+void DEVICE_EVENT_LOG_EXPORT Shutdown();
 
 // If the global instance is initialized, adds an entry to it. Regardless of
 // whether the global instance was intitialzed, this logs the event to
 // LOG(ERROR) if |type| = ERROR or VLOG(1) otherwise.
-void AddEntry(const char* file,
-              int line,
-              LogType type,
-              LogLevel level,
-              const std::string& event);
+void DEVICE_EVENT_LOG_EXPORT AddEntry(const char* file,
+                                      int line,
+                                      LogType type,
+                                      LogLevel level,
+                                      const std::string& event);
 
 // For backwards compatibility with network_event_log. Combines |event| and
 // |description| and calls AddEntry().
-void AddEntryWithDescription(
-    const char* file,
-    int line,
-    LogType type,
-    LogLevel level,
-    const std::string& event,
-    const std::string& description);
+void DEVICE_EVENT_LOG_EXPORT
+AddEntryWithDescription(const char* file,
+                        int line,
+                        LogType type,
+                        LogLevel level,
+                        const std::string& event,
+                        const std::string& description);
 
 // Outputs the log to a formatted string.
 // |order| determines which order to output the events.
 // |format| is a comma-separated string that determines which elements to show.
 //  e.g. "time,desc". Note: order of the strings does not affect the output.
 //  "time" - Include a timestamp.
 //  "file" - Include file and line number.
 //  "type" - Include the event type.
 //  "html" - Include html tags.
 //  "json" - Return JSON format dictionaries containing entries for timestamp,
 //           level, type, file, and event.
 // |types| lists the types included in the output. Prepend "non-" to disclude
 //  a type. e.g. "network,login" or "non-network". Use an empty string for
 //  all types.
 // |max_level| determines the maximum log level to be included in the output.
 // |max_events| limits how many events are output if > 0, otherwise all events
 //  are included.
-std::string GetAsString(StringOrder order,
-                        const std::string& format,
-                        const std::string& types,
-                        LogLevel max_level,
-                        size_t max_events);
+std::string DEVICE_EVENT_LOG_EXPORT GetAsString(StringOrder order,
+                                                const std::string& format,
+                                                const std::string& types,
+                                                LogLevel max_level,
+                                                size_t max_events);
 
-extern const LogLevel kDefaultLogLevel;
+DEVICE_EVENT_LOG_EXPORT extern const LogLevel kDefaultLogLevel;
 
 namespace internal {
 
 // Implementation class for DEVICE_LOG macros. Provides a stream for creating
 // a log string and adds the event using device_event_log::AddEntry on
 // destruction.
-class DeviceEventLogInstance {
+class DEVICE_EVENT_LOG_EXPORT DeviceEventLogInstance {
  public:
   DeviceEventLogInstance(const char* file,
                          int line,
                          device_event_log::LogType type,
                          device_event_log::LogLevel level);
   ~DeviceEventLogInstance();
 
   std::ostream& stream() { return stream_; }
 
  private:
   const char* file_;
   const int line_;
   device_event_log::LogType type_;
   device_event_log::LogLevel level_;
   std::ostringstream stream_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceEventLogInstance);
 };
 
 // Implementation class for DEVICE_PLOG macros. Provides a stream for creating
 // a log string and adds the event, including system error code, using
 // device_event_log::AddEntry on destruction.
-class DeviceEventSystemErrorLogInstance {
+class DEVICE_EVENT_LOG_EXPORT DeviceEventSystemErrorLogInstance {
  public:
   DeviceEventSystemErrorLogInstance(const char* file,
                                     int line,
                                     device_event_log::LogType type,
                                     device_event_log::LogLevel level,
                                     logging::SystemErrorCode err);
   ~DeviceEventSystemErrorLogInstance();
 
   std::ostream& stream() { return log_instance_.stream(); }
 
  private:
   logging::SystemErrorCode err_;
   // Constructor parameters are passed to |log_instance_| which will update the
   // log when it is destroyed (after a string description of |err_| is appended
   // to the stream).
   DeviceEventLogInstance log_instance_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceEventSystemErrorLogInstance);
 };
 
 // Implementation class for SCOPED_LOG_IF_SLOW macros. Tests the elapsed time on
 // destruction and adds a Debug or Error log entry if it exceeds the
 // corresponding expected maximum elapsed time.
-class ScopedDeviceLogIfSlow {
+class DEVICE_EVENT_LOG_EXPORT ScopedDeviceLogIfSlow {
  public:
   ScopedDeviceLogIfSlow(LogType type,
                         const char* file,
                         const std::string& name);
   ~ScopedDeviceLogIfSlow();
 
  private:
   const char* file_;
   LogType type_;
   std::string name_;
   base::ElapsedTimer timer_;
 };
 
 }  // namespace internal
 
 }  // namespace device_event_log
 
 #endif  // DEVICE_EVENT_LOG_DEVICE_EVENT_LOG_H_