Convert //third_party from scoped_ptr to std::unique_ptr

third_party/cld/base/logging.h

 // Copyright (c) 2011 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 _LOGGING_H_
 #define _LOGGING_H_
 
 #include <errno.h>
 #include <string.h>
 #include <time.h>
+
+#include <memory>
 #include <string>
 #include <strstream>
 #include <vector>
 
 #ifndef COMPILER_MSVC
 #include <unistd.h>   // for _exit()
 #endif
 
 #include "base/port.h"
 #include "base/basictypes.h"
 #include "base/commandlineflags.h"
 #include "base/crash.h"
 #include "base/dynamic_annotations.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/stl_decl_msvc.h"
 #include "base/log_severity.h"
 #include "base/vlog_is_on.h"
 #include "global_strip_options.h"
 
 // Make a bunch of macros for logging.  The way to log things is to stream
 // things to LOG(<a particular severity level>).  E.g.,
 //
 //   LOG(INFO) << "Found " << num_cookies << " cookies";
 //
@@ skipping 953 matching lines @@
   static int64 num_messages_[NUM_SEVERITIES];  // under log_mutex
 
   // We keep the data in a separate struct so that each instance of
   // LogMessage uses less stack space.
   struct LogMessageData {
     LogMessageData() {};
 
     int preserved_errno_;         // errno at Init() time
     scoped_array<char> buf_;      // buffer space for non FATAL messages
     char* message_text_;          // Complete message text
-    scoped_ptr<LogStream> stream_alloc_;
+    std::unique_ptr<LogStream> stream_alloc_;
     LogStream* stream_;
     char severity_;               // level of LogMessage (ex. I, W, E, F)
     int line_;                    // line number of file that called LOG
     void (LogMessage::*send_method_)();  // Call this in destructor to send
     union {  // At most one of these is used: union to keep the size low.
       LogSink* sink_;             // NULL or sink to send message to
       vector<string>* outvec_;    // NULL or vector to push message onto
       string* message_;           // NULL or string to write message into
     };
     time_t timestamp_;            // Time of creation of LogMessage
     struct tm tm_time_;           // Time of creation of LogMessage
     size_t num_prefix_chars_;     // # of chars of prefix in this message
     size_t num_chars_to_log_;     // # of chars of msg to send to log
     size_t num_chars_to_syslog_;  // # of chars of msg to send to syslog
     const char* basename_;        // basename of file that called LOG
     const char* fullname_;        // fullname of file that called LOG
     bool has_been_flushed_;       // false => data has not been flushed
     bool first_fatal_;            // true => this was first fatal msg
 
    private:
     DISALLOW_EVIL_CONSTRUCTORS(LogMessageData);
   };
 
   static LogMessageData fatal_msg_data_exclusive_;
   static LogMessageData fatal_msg_data_shared_;
 
-  scoped_ptr<LogMessageData> allocated_;
+  std::unique_ptr<LogMessageData> allocated_;
   LogMessageData* data_;
 
   friend class LogDestination;
 
   DISALLOW_EVIL_CONSTRUCTORS(LogMessage);
 
 protected:
   // Default false; if true, all failures should be as quiet as possible. This
   // is stored in LogMessage, rather than LogMessageData, because all FATAL-
   // level handlers share the same LogMessageData for signal safety reasons.
@@ skipping 357 matching lines @@
 // trace), like LogMessageFatal.
 class NullStreamFatal : public NullStream {
  public:
   NullStreamFatal() { }
   NullStreamFatal(const char* file, int line, const CheckOpString& result) :
       NullStream(file, line, result) { }
   ~NullStreamFatal() ATTRIBUTE_NORETURN { _exit(1); }
 };
 
 #endif // _LOGGING_H_