Update //third_party/protobuf to version 3.

third_party/protobuf/src/google/protobuf/compiler/importer.h

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// http://code.google.com/p/protobuf/
+// 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
@@ skipping 100 matching lines @@
     ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
     ~ValidationErrorCollector();
 
     // implements ErrorCollector ---------------------------------------
     void AddError(const string& filename,
                   const string& element_name,
                   const Message* descriptor,
                   ErrorLocation location,
                   const string& message);
 
+    virtual void AddWarning(const string& filename,
+                            const string& element_name,
+                            const Message* descriptor,
+                            ErrorLocation location,
+                            const string& message);
+
    private:
     SourceTreeDescriptorDatabase* owner_;
   };
   friend class ValidationErrorCollector;
 
   bool using_validation_error_collector_;
   SourceLocationTable source_locations_;
   ValidationErrorCollector validation_error_collector_;
 };
 
@@ skipping 25 matching lines @@
   // separate Importer object to import each one (but use the same
   // DescriptorPool so that they can be cross-linked).
   const FileDescriptor* Import(const string& filename);
 
   // The DescriptorPool in which all imported FileDescriptors and their
   // contents are stored.
   inline const DescriptorPool* pool() const {
     return &pool_;
   }
 
+  void AddUnusedImportTrackFile(const string& file_name);
+  void ClearUnusedImportTrackFiles();
+
  private:
   SourceTreeDescriptorDatabase database_;
   DescriptorPool pool_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
 };
 
 // If the importer encounters problems while trying to import the proto files,
 // it reports them to a MultiFileErrorCollector.
 class LIBPROTOBUF_EXPORT MultiFileErrorCollector {
  public:
   inline MultiFileErrorCollector() {}
   virtual ~MultiFileErrorCollector();
 
   // Line and column numbers are zero-based.  A line number of -1 indicates
   // an error with the entire file (e.g. "not found").
   virtual void AddError(const string& filename, int line, int column,
                         const string& message) = 0;
 
+  virtual void AddWarning(const string& filename, int line, int column,
+                          const string& message) {}
+
  private:
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
 };
 
 // Abstract interface which represents a directory tree containing proto files.
 // Used by the default implementation of Importer to resolve import statements
 // Most users will probably want to use the DiskSourceTree implementation,
 // below.
 class LIBPROTOBUF_EXPORT SourceTree {
  public:
   inline SourceTree() {}
   virtual ~SourceTree();
 
   // Open the given file and return a stream that reads it, or NULL if not
   // found.  The caller takes ownership of the returned object.  The filename
   // must be a path relative to the root of the source tree and must not
   // contain "." or ".." components.
   virtual io::ZeroCopyInputStream* Open(const string& filename) = 0;
 
+  // If Open() returns NULL, calling this method immediately will return an
+  // description of the error.
+  // Subclasses should implement this method and return a meaningful value for
+  // better error reporting.
+  // TODO(xiaofeng): change this to a pure virtual function.
+  virtual string GetLastErrorMessage();
+
  private:
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
 };
 
 // An implementation of SourceTree which loads files from locations on disk.
 // Multiple mappings can be set up to map locations in the DiskSourceTree to
 // locations in the physical filesystem.
 class LIBPROTOBUF_EXPORT DiskSourceTree : public SourceTree {
  public:
   DiskSourceTree();
@@ skipping 49 matching lines @@
     DiskFileToVirtualFile(const string& disk_file,
                           string* virtual_file,
                           string* shadowing_disk_file);
 
   // Given a virtual path, find the path to the file on disk.
   // Return true and update disk_file with the on-disk path if the file exists.
   // Return false and leave disk_file untouched if the file doesn't exist.
   bool VirtualFileToDiskFile(const string& virtual_file, string* disk_file);
 
   // implements SourceTree -------------------------------------------
-  io::ZeroCopyInputStream* Open(const string& filename);
+  virtual io::ZeroCopyInputStream* Open(const string& filename);
+
+  virtual string GetLastErrorMessage();
 
  private:
   struct Mapping {
     string virtual_path;
     string disk_path;
 
     inline Mapping(const string& virtual_path_param,
                    const string& disk_path_param)
       : virtual_path(virtual_path_param), disk_path(disk_path_param) {}
   };
   vector<Mapping> mappings_;
+  string last_error_message_;
 
   // Like Open(), but returns the on-disk path in disk_file if disk_file is
   // non-NULL and the file could be successfully opened.
   io::ZeroCopyInputStream* OpenVirtualFile(const string& virtual_file,
                                            string* disk_file);
 
   // Like Open() but given the actual on-disk path.
   io::ZeroCopyInputStream* OpenDiskFile(const string& filename);
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
 };
 
 }  // namespace compiler
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__