Deleted scoped_ptr.h

We no longer need this, now that we have finished the switch to C++11
and are using std::unique_ptr.

conformance/conformance_cpp.cc

@@ -45,7 +45,6 @@ using google::protobuf::Descriptor;
 using google::protobuf::DescriptorPool;
 using google::protobuf::Message;
 using google::protobuf::MessageFactory;
-using google::protobuf::internal::scoped_ptr;
 using google::protobuf::util::BinaryToJsonString;
 using google::protobuf::util::JsonToBinaryString;
 using google::protobuf::util::NewTypeResolverForDescriptorPool;

conformance/conformance_test.h

@@ -256,8 +256,7 @@ class ConformanceTestSuite {
   // The set of tests that the testee opted out of;
   std::set<std::string> skipped_;
 
-  google::protobuf::internal::scoped_ptr<google::protobuf::util::TypeResolver>
-      type_resolver_;
+  std::unique_ptr<google::protobuf::util::TypeResolver> type_resolver_;
   std::string type_url_;
 };
 

conformance/conformance_test_runner.cc

@@ -68,7 +68,6 @@
 
 using conformance::ConformanceRequest;
 using conformance::ConformanceResponse;
-using google::protobuf::internal::scoped_array;
 using google::protobuf::StringAppendF;
 using std::string;
 using std::vector;
@@ -183,7 +182,7 @@ class ForkPipeRunner : public google::protobuf::ConformanceTestRunner {
       CHECK_SYSCALL(close(toproc_pipe_fd[1]));
       CHECK_SYSCALL(close(fromproc_pipe_fd[0]));
 
-      scoped_array<char> executable(new char[executable_.size() + 1]);
+      std::unique_ptr<char[]> executable(new char[executable_.size() + 1]);
       memcpy(executable.get(), executable_.c_str(), executable_.size());
       executable[executable_.size()] = '\0';
 

src/google/protobuf/compiler/csharp/csharp_enum.cc

@@ -43,8 +43,6 @@
 #include <google/protobuf/compiler/csharp/csharp_helpers.h>
 #include <google/protobuf/compiler/csharp/csharp_options.h>
 
-using google::protobuf::internal::scoped_ptr;
-
 namespace google {
 namespace protobuf {
 namespace compiler {

src/google/protobuf/compiler/csharp/csharp_field_base.cc

@@ -46,8 +46,6 @@
 #include <google/protobuf/compiler/csharp/csharp_helpers.h>
 #include <google/protobuf/compiler/csharp/csharp_names.h>
 
-using google::protobuf::internal::scoped_ptr;
-
 namespace google {
 namespace protobuf {
 namespace compiler {

src/google/protobuf/compiler/csharp/csharp_generator.cc

@@ -44,8 +44,6 @@
 #include <google/protobuf/compiler/csharp/csharp_options.h>
 #include <google/protobuf/compiler/csharp/csharp_reflection_class.h>
 
-using google::protobuf::internal::scoped_ptr;
-
 namespace google {
 namespace protobuf {
 namespace compiler {
@@ -100,7 +98,7 @@ bool Generator::Generate(
     *error = filename_error;
     return false;
   }
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
       generator_context->Open(filename));
   io::Printer printer(output.get(), '$');
 

src/google/protobuf/compiler/csharp/csharp_map_field.cc

@@ -63,9 +63,9 @@ void MapFieldGenerator::GenerateMembers(io::Printer* printer) {
       descriptor_->message_type()->FindFieldByName("value");
   variables_["key_type_name"] = type_name(key_descriptor);
   variables_["value_type_name"] = type_name(value_descriptor);
-  scoped_ptr<FieldGeneratorBase> key_generator(
+  std::unique_ptr<FieldGeneratorBase> key_generator(
       CreateFieldGenerator(key_descriptor, 1, this->options()));
-  scoped_ptr<FieldGeneratorBase> value_generator(
+  std::unique_ptr<FieldGeneratorBase> value_generator(
       CreateFieldGenerator(value_descriptor, 2, this->options()));
 
   printer->Print(

src/google/protobuf/compiler/csharp/csharp_message.cc

@@ -49,8 +49,6 @@
 #include <google/protobuf/compiler/csharp/csharp_message.h>
 #include <google/protobuf/compiler/csharp/csharp_names.h>
 
-using google::protobuf::internal::scoped_ptr;
-
 namespace google {
 namespace protobuf {
 namespace compiler {
@@ -184,7 +182,7 @@ void MessageGenerator::Generate(io::Printer* printer) {
       "field_name", fieldDescriptor->name(),
       "field_constant_name", GetFieldConstantName(fieldDescriptor),
       "index", SimpleItoa(fieldDescriptor->number()));
-    scoped_ptr<FieldGeneratorBase> generator(
+    std::unique_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(fieldDescriptor));
     generator->GenerateMembers(printer);
     printer->Print("\n");
@@ -293,7 +291,7 @@ void MessageGenerator::GenerateCloningCode(io::Printer* printer) {
   // Clone non-oneof fields first
   for (int i = 0; i < descriptor_->field_count(); i++) {
     if (!descriptor_->field(i)->containing_oneof()) {
-      scoped_ptr<FieldGeneratorBase> generator(
+      std::unique_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
       generator->GenerateCloningCode(printer);
     }
@@ -307,7 +305,7 @@ void MessageGenerator::GenerateCloningCode(io::Printer* printer) {
     printer->Indent();
     for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
       const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
-      scoped_ptr<FieldGeneratorBase> generator(CreateFieldGeneratorInternal(field));
+      std::unique_ptr<FieldGeneratorBase> generator(CreateFieldGeneratorInternal(field));
       vars["field_property_name"] = GetPropertyName(field);
       printer->Print(
           vars,
@@ -361,7 +359,7 @@ void MessageGenerator::GenerateFrameworkMethods(io::Printer* printer) {
         "  }\n");
     printer->Indent();
     for (int i = 0; i < descriptor_->field_count(); i++) {
-        scoped_ptr<FieldGeneratorBase> generator(
+      std::unique_ptr<FieldGeneratorBase> generator(
             CreateFieldGeneratorInternal(descriptor_->field(i)));
         generator->WriteEquals(printer);
     }
@@ -382,7 +380,7 @@ void MessageGenerator::GenerateFrameworkMethods(io::Printer* printer) {
         "  int hash = 1;\n");
     printer->Indent();
     for (int i = 0; i < descriptor_->field_count(); i++) {
-        scoped_ptr<FieldGeneratorBase> generator(
+      std::unique_ptr<FieldGeneratorBase> generator(
             CreateFieldGeneratorInternal(descriptor_->field(i)));
         generator->WriteHash(printer);
     }
@@ -413,7 +411,7 @@ void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer)
 
   // Serialize all the fields
   for (int i = 0; i < fields_by_number().size(); i++) {
-    scoped_ptr<FieldGeneratorBase> generator(
+    std::unique_ptr<FieldGeneratorBase> generator(
       CreateFieldGeneratorInternal(fields_by_number()[i]));
     generator->GenerateSerializationCode(printer);
   }
@@ -435,7 +433,7 @@ void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer)
   printer->Indent();
   printer->Print("int size = 0;\n");
   for (int i = 0; i < descriptor_->field_count(); i++) {
-    scoped_ptr<FieldGeneratorBase> generator(
+    std::unique_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(descriptor_->field(i)));
     generator->GenerateSerializedSizeCode(printer);
   }
@@ -469,7 +467,7 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
   // Merge non-oneof fields
   for (int i = 0; i < descriptor_->field_count(); i++) {
     if (!descriptor_->field(i)->containing_oneof()) {      
-      scoped_ptr<FieldGeneratorBase> generator(
+      std::unique_ptr<FieldGeneratorBase> generator(
           CreateFieldGeneratorInternal(descriptor_->field(i)));
       generator->GenerateMergingCode(printer);
     }
@@ -487,7 +485,7 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
         vars,
         "case $property_name$OneofCase.$field_property_name$:\n");
       printer->Indent();
-      scoped_ptr<FieldGeneratorBase> generator(CreateFieldGeneratorInternal(field));
+      std::unique_ptr<FieldGeneratorBase> generator(CreateFieldGeneratorInternal(field));
       generator->GenerateMergingCode(printer);
       printer->Print("break;\n");
       printer->Outdent();
@@ -546,7 +544,7 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
 
     printer->Print("case $tag$: {\n", "tag", SimpleItoa(tag));
     printer->Indent();
-    scoped_ptr<FieldGeneratorBase> generator(
+    std::unique_ptr<FieldGeneratorBase> generator(
         CreateFieldGeneratorInternal(field));
     generator->GenerateParsingCode(printer);
     printer->Print("break;\n");

src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc

@@ -66,11 +66,11 @@ void RepeatedMessageFieldGenerator::GenerateMembers(io::Printer* printer) {
   // "create single field generator for this repeated field"
   // function, but it doesn't seem worth it for just this.
   if (IsWrapperType(descriptor_)) {
-    scoped_ptr<FieldGeneratorBase> single_generator(
+    std::unique_ptr<FieldGeneratorBase> single_generator(
       new WrapperFieldGenerator(descriptor_, fieldOrdinal_, this->options()));
     single_generator->GenerateCodecCode(printer);
   } else {
-    scoped_ptr<FieldGeneratorBase> single_generator(
+    std::unique_ptr<FieldGeneratorBase> single_generator(
       new MessageFieldGenerator(descriptor_, fieldOrdinal_, this->options()));
     single_generator->GenerateCodecCode(printer);
   }

src/google/protobuf/compiler/javanano/javanano_field.cc

@@ -76,7 +76,7 @@ FieldGeneratorMap::FieldGeneratorMap(
     const Descriptor* descriptor, const Params &params)
   : descriptor_(descriptor),
     field_generators_(
-      new scoped_ptr<FieldGenerator>[descriptor->field_count()]) {
+      new std::unique_ptr<FieldGenerator>[descriptor->field_count()]) {
 
   int next_has_bit_index = 0;
   bool saved_defaults_needed = false;

src/google/protobuf/compiler/javanano/javanano_field.h

@@ -103,7 +103,7 @@ class FieldGeneratorMap {
 
  private:
   const Descriptor* descriptor_;
-  scoped_array<scoped_ptr<FieldGenerator> > field_generators_;
+  std::unique_ptr<std::unique_ptr<FieldGenerator>[]> field_generators_;
   int total_bits_;
   bool saved_defaults_needed_;
 

src/google/protobuf/compiler/javanano/javanano_file.cc

@@ -221,7 +221,7 @@ static void GenerateSibling(const string& package_dir,
   string filename = package_dir + descriptor->name() + ".java";
   file_list->push_back(filename);
 
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
     output_directory->Open(filename));
   io::Printer printer(output.get(), '$');
 

src/google/protobuf/compiler/javanano/javanano_generator.cc

@@ -200,7 +200,7 @@ bool JavaNanoGenerator::Generate(const FileDescriptor* file,
     all_files.push_back(java_filename);
 
     // Generate main java file.
-    scoped_ptr<io::ZeroCopyOutputStream> output(
+    std::unique_ptr<io::ZeroCopyOutputStream> output(
       output_directory->Open(java_filename));
     io::Printer printer(output.get(), '$');
     file_generator.Generate(&printer);
@@ -213,7 +213,7 @@ bool JavaNanoGenerator::Generate(const FileDescriptor* file,
   if (!output_list_file.empty()) {
     // Generate output list.  This is just a simple text file placed in a
     // deterministic location which lists the .java files being generated.
-    scoped_ptr<io::ZeroCopyOutputStream> srclist_raw_output(
+    std::unique_ptr<io::ZeroCopyOutputStream> srclist_raw_output(
       output_directory->Open(output_list_file));
     io::Printer srclist_printer(srclist_raw_output.get(), '$');
     for (int i = 0; i < all_files.size(); i++) {

src/google/protobuf/compiler/javanano/javanano_message.cc

@@ -349,7 +349,7 @@ GenerateMessageSerializationMethods(io::Printer* printer) {
     return;
   }
 
-  scoped_array<const FieldDescriptor*> sorted_fields(
+  std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
     SortFieldsByNumber(descriptor_));
 
   printer->Print(
@@ -391,7 +391,7 @@ GenerateMessageSerializationMethods(io::Printer* printer) {
 }
 
 void MessageGenerator::GenerateMergeFromMethods(io::Printer* printer) {
-  scoped_array<const FieldDescriptor*> sorted_fields(
+  std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
     SortFieldsByNumber(descriptor_));
 
   printer->Print(

src/google/protobuf/compiler/objectivec/objectivec_field.cc

@@ -411,9 +411,9 @@ FieldGeneratorMap::FieldGeneratorMap(const Descriptor* descriptor,
                                      const Options& options)
     : descriptor_(descriptor),
       field_generators_(
-          new scoped_ptr<FieldGenerator>[descriptor->field_count()]),
+          new std::unique_ptr<FieldGenerator>[descriptor->field_count()]),
       extension_generators_(
-          new scoped_ptr<FieldGenerator>[descriptor->extension_count()]) {
+          new std::unique_ptr<FieldGenerator>[descriptor->extension_count()]) {
   // Construct all the FieldGenerators.
   for (int i = 0; i < descriptor->field_count(); i++) {
     field_generators_[i].reset(

src/google/protobuf/compiler/objectivec/objectivec_field.h

@@ -182,8 +182,8 @@ class FieldGeneratorMap {
 
  private:
   const Descriptor* descriptor_;
-  scoped_array<scoped_ptr<FieldGenerator> > field_generators_;
-  scoped_array<scoped_ptr<FieldGenerator> > extension_generators_;
+  std::unique_ptr<std::unique_ptr<FieldGenerator>[]> field_generators_;
+  std::unique_ptr<std::unique_ptr<FieldGenerator>[]> extension_generators_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldGeneratorMap);
 };

src/google/protobuf/compiler/objectivec/objectivec_generator.cc

@@ -142,7 +142,7 @@ bool ObjectiveCGenerator::GenerateAll(const std::vector<const FileDescriptor*>&
 
     // Generate header.
     {
-      scoped_ptr<io::ZeroCopyOutputStream> output(
+      std::unique_ptr<io::ZeroCopyOutputStream> output(
           context->Open(filepath + ".pbobjc.h"));
       io::Printer printer(output.get(), '$');
       file_generator.GenerateHeader(&printer);
@@ -150,7 +150,7 @@ bool ObjectiveCGenerator::GenerateAll(const std::vector<const FileDescriptor*>&
 
     // Generate m file.
     {
-      scoped_ptr<io::ZeroCopyOutputStream> output(
+      std::unique_ptr<io::ZeroCopyOutputStream> output(
           context->Open(filepath + ".pbobjc.m"));
       io::Printer printer(output.get(), '$');
       file_generator.GenerateSource(&printer);

src/google/protobuf/compiler/objectivec/objectivec_map_field.h

@@ -54,7 +54,7 @@ class MapFieldGenerator : public RepeatedFieldGenerator {
   virtual void DetermineForwardDeclarations(std::set<string>* fwd_decls) const;
 
  private:
-  scoped_ptr<FieldGenerator> value_field_generator_;
+  std::unique_ptr<FieldGenerator> value_field_generator_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldGenerator);
 };

src/google/protobuf/compiler/objectivec/objectivec_message.cc

@@ -310,7 +310,7 @@ void MessageGenerator::GenerateMessageHeader(io::Printer* printer) {
       "classname", class_name_);
 
   if (descriptor_->field_count()) {
-    scoped_array<const FieldDescriptor*> sorted_fields(
+    std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
         SortFieldsByNumber(descriptor_));
 
     printer->Print("typedef GPB_ENUM($classname$_FieldNumber) {\n",
@@ -420,9 +420,9 @@ void MessageGenerator::GenerateSource(io::Printer* printer) {
           .GeneratePropertyImplementation(printer);
     }
 
-    scoped_array<const FieldDescriptor*> sorted_fields(
+    std::unique_ptr<const FieldDescriptor*[]> sorted_fields(
         SortFieldsByNumber(descriptor_));
-    scoped_array<const FieldDescriptor*> size_order_fields(
+    std::unique_ptr<const FieldDescriptor*[]> size_order_fields(
         SortFieldsByStorageSize(descriptor_));
 
     std::vector<const Descriptor::ExtensionRange*> sorted_extensions;

src/google/protobuf/compiler/php/php_generator.cc

@@ -40,8 +40,6 @@
 
 #include <sstream>
 
-using google::protobuf::internal::scoped_ptr;
-
 const std::string kDescriptorFile = "google/protobuf/descriptor.proto";
 const std::string kEmptyFile = "google/protobuf/empty.proto";
 const std::string kEmptyMetadataFile = "GPBMetadata/Google/Protobuf/GPBEmpty.php";
@@ -948,7 +946,7 @@ void GenerateMetadataFile(const FileDescriptor* file,
                           bool is_descriptor,
                           GeneratorContext* generator_context) {
   std::string filename = GeneratedMetadataFileName(file->name(), is_descriptor);
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
       generator_context->Open(filename));
   io::Printer printer(output.get(), '^');
 
@@ -983,7 +981,7 @@ void GenerateMetadataFile(const FileDescriptor* file,
 void GenerateEnumFile(const FileDescriptor* file, const EnumDescriptor* en,
                       bool is_descriptor, GeneratorContext* generator_context) {
   std::string filename = GeneratedEnumFileName(en, is_descriptor);
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
       generator_context->Open(filename));
   io::Printer printer(output.get(), '^');
 
@@ -1042,7 +1040,7 @@ void GenerateMessageFile(const FileDescriptor* file, const Descriptor* message,
   }
 
   std::string filename = GeneratedMessageFileName(message, is_descriptor);
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
       generator_context->Open(filename));
   io::Printer printer(output.get(), '^');
 
@@ -1143,7 +1141,7 @@ void GenerateServiceFile(const FileDescriptor* file,
   const ServiceDescriptor* service, bool is_descriptor,
   GeneratorContext* generator_context) {
   std::string filename = GeneratedServiceFileName(service, is_descriptor);
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
       generator_context->Open(filename));
   io::Printer printer(output.get(), '^');
 

src/google/protobuf/compiler/ruby/ruby_generator.cc

@@ -39,8 +39,6 @@
 
 #include <google/protobuf/compiler/ruby/ruby_generator.h>
 
-using google::protobuf::internal::scoped_ptr;
-
 namespace google {
 namespace protobuf {
 namespace compiler {
@@ -488,7 +486,7 @@ bool Generator::Generate(
     return false;
   }
 
-  scoped_ptr<io::ZeroCopyOutputStream> output(
+  std::unique_ptr<io::ZeroCopyOutputStream> output(
       generator_context->Open(GetOutputFilename(file->name())));
   io::Printer printer(output.get(), '$');
 

src/google/protobuf/dynamic_message.cc

@@ -232,10 +232,10 @@ class DynamicMessage : public Message {
     std::unique_ptr<uint32[]> offsets;
     std::unique_ptr<uint32[]> has_bits_indices;
     std::unique_ptr<const GeneratedMessageReflection> reflection;
-    // Don't use a scoped_ptr to hold the prototype: the destructor for
+    // Don't use a unique_ptr to hold the prototype: the destructor for
     // DynamicMessage needs to know whether it is the prototype, and does so by
     // looking back at this field. This would assume details about the
-    // implementation of scoped_ptr.
+    // implementation of unique_ptr.
     const DynamicMessage* prototype;
     int weak_field_map_offset;  // The offset for the weak_field_map;
 

src/google/protobuf/stubs/common.h

@@ -231,18 +231,6 @@ class FatalException : public std::exception {
 // in some versions of MSVC.
 using std::string;
 
-// TODO(gerbens) remove once an extraction cycle has removed all references
-namespace internal {
-template <typename T>
-using scoped_ptr = std::unique_ptr<T>;
-template <typename T>
-using scoped_array = std::unique_ptr<T[]>;
-}  // namespace internal
-template <typename T>
-using scoped_ptr = std::unique_ptr<T>;
-template <typename T>
-using scoped_array = std::unique_ptr<T[]>;
-
 }  // namespace protobuf
 }  // namespace google
 

src/google/protobuf/stubs/map_util.h

@@ -654,7 +654,8 @@ InsertOrReturnExisting(
 //     delete EraseKeyReturnValuePtr(&my_map, "abc");
 //
 // Use returned value:
-//     scoped_ptr<MyType> value_ptr(EraseKeyReturnValuePtr(&my_map, "abc"));
+//     std::unique_ptr<MyType> value_ptr(
+//         EraseKeyReturnValuePtr(&my_map, "abc"));
 //     if (value_ptr.get())
 //       value_ptr->DoSomething();
 //

src/google/protobuf/stubs/once_unittest.cc

@@ -207,7 +207,7 @@ GOOGLE_PROTOBUF_DECLARE_ONCE(multiple_threads_once);
 TEST_F(OnceInitTest, MultipleThreads) {
   SetOnces(&multiple_threads_once, NULL);
 
-  scoped_ptr<TestThread> threads[4];
+  std::unique_ptr<TestThread> threads[4];
   EXPECT_EQ(INIT_NOT_STARTED, CurrentState());
   for (int i = 0; i < 4; i++) {
     threads[i].reset(RunInitOnceInNewThread());
@@ -224,7 +224,7 @@ GOOGLE_PROTOBUF_DECLARE_ONCE(multiple_threads_blocked_once2);
 TEST_F(OnceInitTest, MultipleThreadsBlocked) {
   SetOnces(&multiple_threads_blocked_once1, &multiple_threads_blocked_once2);
 
-  scoped_ptr<TestThread> threads[8];
+  std::unique_ptr<TestThread> threads[8];
   EXPECT_EQ(INIT_NOT_STARTED, CurrentState());
 
   BlockInit();

src/google/protobuf/stubs/scoped_ptr.h

-// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_
-#define GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_
-
-#include <google/protobuf/stubs/port.h>
-
-namespace google {
-namespace protobuf {
-
-// ===================================================================
-// from google3/base/scoped_ptr.h
-
-namespace internal {
-
-//  This is an implementation designed to match the anticipated future TR2
-//  implementation of the scoped_ptr class, and its closely-related brethren,
-//  scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
-
-template <class C> class scoped_ptr;
-template <class C> class scoped_array;
-
-// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
-// automatically deletes the pointer it holds (if any).
-// That is, scoped_ptr<T> owns the T object that it points to.
-// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
-//
-// The size of a scoped_ptr is small:
-// sizeof(scoped_ptr<C>) == sizeof(C*)
-template <class C>
-class scoped_ptr {
- public:
-
-  // The element type
-  typedef C element_type;
-
-  // Constructor.  Defaults to initializing with NULL.
-  // There is no way to create an uninitialized scoped_ptr.
-  // The input parameter must be allocated with new.
-  explicit scoped_ptr(C* p = NULL) : ptr_(p) { }
-
-  // Destructor.  If there is a C object, delete it.
-  // We don't need to test ptr_ == NULL because C++ does that for us.
-  ~scoped_ptr() {
-    enum { type_must_be_complete = sizeof(C) };
-    delete ptr_;
-  }
-
-  // Reset.  Deletes the current owned object, if any.
-  // Then takes ownership of a new object, if given.
-  // this->reset(this->get()) works.
-  void reset(C* p = NULL) {
-    if (p != ptr_) {
-      enum { type_must_be_complete = sizeof(C) };
-      delete ptr_;
-      ptr_ = p;
-    }
-  }
-
-  // Accessors to get the owned object.
-  // operator* and operator-> will assert() if there is no current object.
-  C& operator*() const {
-    assert(ptr_ != NULL);
-    return *ptr_;
-  }
-  C* operator->() const  {
-    assert(ptr_ != NULL);
-    return ptr_;
-  }
-  C* get() const { return ptr_; }
-
-  // Comparison operators.
-  // These return whether two scoped_ptr refer to the same object, not just to
-  // two different but equal objects.
-  bool operator==(C* p) const { return ptr_ == p; }
-  bool operator!=(C* p) const { return ptr_ != p; }
-
-  // Swap two scoped pointers.
-  void swap(scoped_ptr& p2) {
-    C* tmp = ptr_;
-    ptr_ = p2.ptr_;
-    p2.ptr_ = tmp;
-  }
-
-  // Release a pointer.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  C* release() {
-    C* retVal = ptr_;
-    ptr_ = NULL;
-    return retVal;
-  }
-
- private:
-  C* ptr_;
-
-  // Forbid comparison of scoped_ptr types.  If C2 != C, it totally doesn't
-  // make sense, and if C2 == C, it still doesn't make sense because you should
-  // never have the same object owned by two different scoped_ptrs.
-  template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
-  template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;
-
-  // Disallow evil constructors
-  scoped_ptr(const scoped_ptr&);
-  void operator=(const scoped_ptr&);
-};
-
-// scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate
-// with new [] and the destructor deletes objects with delete [].
-//
-// As with scoped_ptr<C>, a scoped_array<C> either points to an object
-// or is NULL.  A scoped_array<C> owns the object that it points to.
-//
-// Size: sizeof(scoped_array<C>) == sizeof(C*)
-template <class C>
-class scoped_array {
- public:
-
-  // The element type
-  typedef C element_type;
-
-  // Constructor.  Defaults to initializing with NULL.
-  // There is no way to create an uninitialized scoped_array.
-  // The input parameter must be allocated with new [].
-  explicit scoped_array(C* p = NULL) : array_(p) { }
-
-  // Destructor.  If there is a C object, delete it.
-  // We don't need to test ptr_ == NULL because C++ does that for us.
-  ~scoped_array() {
-    enum { type_must_be_complete = sizeof(C) };
-    delete[] array_;
-  }
-
-  // Reset.  Deletes the current owned object, if any.
-  // Then takes ownership of a new object, if given.
-  // this->reset(this->get()) works.
-  void reset(C* p = NULL) {
-    if (p != array_) {
-      enum { type_must_be_complete = sizeof(C) };
-      delete[] array_;
-      array_ = p;
-    }
-  }
-
-  // Get one element of the current object.
-  // Will assert() if there is no current object, or index i is negative.
-  C& operator[](std::ptrdiff_t i) const {
-    assert(i >= 0);
-    assert(array_ != NULL);
-    return array_[i];
-  }
-
-  // Get a pointer to the zeroth element of the current object.
-  // If there is no current object, return NULL.
-  C* get() const {
-    return array_;
-  }
-
-  // Comparison operators.
-  // These return whether two scoped_array refer to the same object, not just to
-  // two different but equal objects.
-  bool operator==(C* p) const { return array_ == p; }
-  bool operator!=(C* p) const { return array_ != p; }
-
-  // Swap two scoped arrays.
-  void swap(scoped_array& p2) {
-    C* tmp = array_;
-    array_ = p2.array_;
-    p2.array_ = tmp;
-  }
-
-  // Release an array.
-  // The return value is the current pointer held by this object.
-  // If this object holds a NULL pointer, the return value is NULL.
-  // After this operation, this object will hold a NULL pointer,
-  // and will not own the object any more.
-  C* release() {
-    C* retVal = array_;
-    array_ = NULL;
-    return retVal;
-  }
-
- private:
-  C* array_;
-
-  // Forbid comparison of different scoped_array types.
-  template <class C2> bool operator==(scoped_array<C2> const& p2) const;
-  template <class C2> bool operator!=(scoped_array<C2> const& p2) const;
-
-  // Disallow evil constructors
-  scoped_array(const scoped_array&);
-  void operator=(const scoped_array&);
-};
-
-}  // namespace internal
-
-// We made these internal so that they would show up as such in the docs,
-// but we don't want to stick "internal::" in front of them everywhere.
-using internal::scoped_ptr;
-using internal::scoped_array;
-
-
-}  // namespace protobuf
-}  // namespace google
-
-#endif  // GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_

src/google/protobuf/stubs/strutil.cc

@@ -469,7 +469,7 @@ int UnescapeCEscapeString(const string& src, string* dest) {
 
 int UnescapeCEscapeString(const string& src, string* dest,
                           std::vector<string> *errors) {
-  scoped_array<char> unescaped(new char[src.size() + 1]);
+  std::unique_ptr<char[]> unescaped(new char[src.size() + 1]);
   int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), errors);
   GOOGLE_CHECK(dest);
   dest->assign(unescaped.get(), len);
@@ -477,7 +477,7 @@ int UnescapeCEscapeString(const string& src, string* dest,
 }
 
 string UnescapeCEscapeString(const string& src) {
-  scoped_array<char> unescaped(new char[src.size() + 1]);
+  std::unique_ptr<char[]> unescaped(new char[src.size() + 1]);
   int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), NULL);
   return string(unescaped.get(), len);
 }
@@ -620,7 +620,7 @@ namespace strings {
 
 string Utf8SafeCEscape(const string& src) {
   const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
-  scoped_array<char> dest(new char[dest_length]);
+  std::unique_ptr<char[]> dest(new char[dest_length]);
   const int len = CEscapeInternal(src.data(), src.size(),
                                   dest.get(), dest_length, false, true);
   GOOGLE_DCHECK_GE(len, 0);
@@ -629,7 +629,7 @@ string Utf8SafeCEscape(const string& src) {
 
 string CHexEscape(const string& src) {
   const int dest_length = src.size() * 4 + 1; // Maximum possible expansion
-  scoped_array<char> dest(new char[dest_length]);
+  std::unique_ptr<char[]> dest(new char[dest_length]);
   const int len = CEscapeInternal(src.data(), src.size(),
                                   dest.get(), dest_length, true, false);
   GOOGLE_DCHECK_GE(len, 0);