Fix for ICE-4841 - added no copy option when creating input stream

10 files changed, 129 insertions, 74 deletions

diff --git a/cpp/src/Freeze/ObjectStore.cpp b/cpp/src/Freeze/ObjectStore.cpp
index 44a9fb2b02f..bf4f3b0545d 100644
--- a/cpp/src/Freeze/ObjectStore.cpp
+++ b/cpp/src/Freeze/ObjectStore.cpp
@@ -346,10 +346,7 @@ Freeze::ObjectStoreBase::unmarshal(Identity& ident,
                                    const EncodingVersion& encoding)
 {
     IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
-    IceInternal::BasicStream stream(instance.get(), encoding, true);
-    stream.b.resize(bytes.size());
-    memcpy(&stream.b[0], &bytes[0], bytes.size());
-    stream.i = stream.b.begin();
+    IceInternal::BasicStream stream(instance.get(), encoding, &bytes[0], &bytes[0] + bytes.size());
     stream.read(ident);
 }
 
@@ -385,11 +382,8 @@ Freeze::ObjectStoreBase::unmarshal(ObjectRecord& v,
                                    bool keepStats)
 {
     IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
-    IceInternal::BasicStream stream(instance.get(), encoding, true);
+    IceInternal::BasicStream stream(instance.get(), encoding, &bytes[0], &bytes[0] + bytes.size());
     stream.sliceObjects(false);
-    stream.b.resize(bytes.size());
-    memcpy(&stream.b[0], &bytes[0], bytes.size());
-    stream.i = stream.b.begin();
     stream.startReadEncaps();
     
     if(keepStats)
diff --git a/cpp/src/FreezeScript/DumpDescriptors.cpp b/cpp/src/FreezeScript/DumpDescriptors.cpp
index 4b61939857f..4661cc5a9fb 100644
--- a/cpp/src/FreezeScript/DumpDescriptors.cpp
+++ b/cpp/src/FreezeScript/DumpDescriptors.cpp
@@ -1269,12 +1269,12 @@ FreezeScript::RecordDescriptor::execute(const SymbolTablePtr& /*sym*/, ExecuteIn
             Ice::ByteSeq keyBytes;
             keyBytes.resize(dbKey.get_size());
             memcpy(&keyBytes[0], dbKey.get_data(), dbKey.get_size());
-            Ice::InputStreamPtr inKey = Ice::createInputStream(info->communicator, keyBytes);
+            Ice::InputStreamPtr inKey = Ice::createInputStream(info->communicator, keyBytes, false);
 
             Ice::ByteSeq valueBytes;
             valueBytes.resize(dbValue.get_size());
             memcpy(&valueBytes[0], dbValue.get_data(), dbValue.get_size());
-            Ice::InputStreamPtr inValue = Ice::createInputStream(info->communicator, valueBytes);
+            Ice::InputStreamPtr inValue = Ice::createInputStream(info->communicator, valueBytes, false);
             inValue->startEncapsulation();
 
             //
diff --git a/cpp/src/FreezeScript/Transformer.cpp b/cpp/src/FreezeScript/Transformer.cpp
index 5048e82cffc..c10c13e37a9 100644
--- a/cpp/src/FreezeScript/Transformer.cpp
+++ b/cpp/src/FreezeScript/Transformer.cpp
@@ -1960,8 +1960,8 @@ FreezeScript::RecordDescriptor::transformRecord(const Ice::ByteSeq& inKeyBytes,
                                                 Ice::ByteSeq& outKeyBytes,
                                                 Ice::ByteSeq& outValueBytes)
 {
-    Ice::InputStreamPtr inKey = Ice::createInputStream(_info->communicator, inKeyBytes);
-    Ice::InputStreamPtr inValue = Ice::createInputStream(_info->communicator, inValueBytes);
+    Ice::InputStreamPtr inKey = Ice::createInputStream(_info->communicator, inKeyBytes, false);
+    Ice::InputStreamPtr inValue = Ice::createInputStream(_info->communicator, inValueBytes, false);
     inValue->startEncapsulation();
 
     Ice::OutputStreamPtr outKey = Ice::createOutputStream(_info->communicator);
diff --git a/cpp/src/Ice/BasicStream.cpp b/cpp/src/Ice/BasicStream.cpp
index 46f6e440241..e30462bdbb7 100644
--- a/cpp/src/Ice/BasicStream.cpp
+++ b/cpp/src/Ice/BasicStream.cpp
@@ -112,6 +112,30 @@ IceInternal::BasicStream::BasicStream(Instance* instance, const EncodingVersion&
     _preAllocatedWriteEncaps.encoding = encoding;
 }
 
+IceInternal::BasicStream::BasicStream(Instance* instance, const EncodingVersion& encoding, const Byte* begin, 
+                                      const Byte* end) :
+    IceInternal::Buffer(begin, end),
+    _instance(instance),
+    _closure(0),
+    _encoding(encoding),
+    _currentReadEncaps(0),
+    _currentWriteEncaps(0),
+    _sliceObjects(true),
+    _messageSizeMax(_instance->messageSizeMax()), // Cached for efficiency.
+    _unlimited(false),
+    _stringConverter(instance->initializationData().stringConverter),
+    _wstringConverter(instance->initializationData().wstringConverter),
+    _startSeq(-1),
+    _sizePos(-1)
+{
+    //
+    // Initialize the encoding members of our pre-allocated encapsulations, in case
+    // this stream is used without an explicit encapsulation.
+    //
+    _preAllocatedReadEncaps.encoding = encoding;
+    _preAllocatedWriteEncaps.encoding = encoding;
+}
+
 void
 IceInternal::BasicStream::clear()
 {
diff --git a/cpp/src/Ice/Buffer.cpp b/cpp/src/Ice/Buffer.cpp
index bed4c088b92..ec1fdf6730a 100644
--- a/cpp/src/Ice/Buffer.cpp
+++ b/cpp/src/Ice/Buffer.cpp
@@ -30,14 +30,28 @@ IceInternal::Buffer::Container::Container(size_type maxCapacity) :
 {
 }
 
+IceInternal::Buffer::Container::Container(const_iterator beg, const_iterator end) :
+    _buf(const_cast<iterator>(beg)),
+    _size(end - beg),
+    _capacity(0),
+    _maxCapacity(0),
+    _shrinkCounter(0)
+{
+}
+
 IceInternal::Buffer::Container::~Container()
 {
-    ::free(_buf);
+    if(_buf && _capacity > 0)
+    {
+        ::free(_buf);
+    }
 }
 
 void
 IceInternal::Buffer::Container::swap(Container& other)
 {
+    assert(!_buf || _capacity > 0);
+
     std::swap(_buf, other._buf);
 
     std::swap(_size, other._size);
@@ -48,6 +62,8 @@ IceInternal::Buffer::Container::swap(Container& other)
 void
 IceInternal::Buffer::Container::clear()
 {
+    assert(!_buf || _capacity > 0);
+
     free(_buf);
     _buf = 0;
     _size = 0;
@@ -57,6 +73,8 @@ IceInternal::Buffer::Container::clear()
 void
 IceInternal::Buffer::Container::reserve(size_type n)
 {
+    assert(!_buf || _capacity > 0);
+
     size_type c = _capacity;
     if(n > _capacity)
     {
diff --git a/cpp/src/Ice/Initialize.cpp b/cpp/src/Ice/Initialize.cpp
index 30a3a4a1672..60adb309571 100644
--- a/cpp/src/Ice/Initialize.cpp
+++ b/cpp/src/Ice/Initialize.cpp
@@ -39,6 +39,24 @@ extern IceUtil::Handle<IceInternal::GC> theCollector;
 
 }
 
+namespace
+{
+
+pair<const Byte*, const Byte*>
+makePair(const vector<Byte>& v)
+{
+    if(v.empty())
+    {
+        return pair<const Byte*, const Byte*>(0, 0);
+    }
+    else
+    {
+        return pair<const Byte*, const Byte*>(&v[0], &v[0] + v.size());
+    }
+}
+
+}
+
 void
 Ice::collectGarbage()
 {
@@ -253,26 +271,53 @@ Ice::initialize(const InitializationData& initData, Int version)
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes)
 {
-    return new InputStreamI(communicator, bytes);
+    return createInputStream(communicator, makePair(bytes));
 }
 
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v)
 {
-    return new InputStreamI(communicator, bytes, v);
+    return createInputStream(communicator, makePair(bytes), v);
+}
+
+InputStreamPtr
+Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, bool copyBytes)
+{
+    return createInputStream(communicator, makePair(bytes), copyBytes);
+}
+
+InputStreamPtr
+Ice::createInputStream(const CommunicatorPtr& communicator, const vector<Byte>& bytes, const EncodingVersion& v,
+                       bool copyBytes)
+{
+    return createInputStream(communicator, makePair(bytes), v, copyBytes);
 }
 
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes)
 {
-    return new InputStreamI(communicator, bytes);
+    return createInputStream(communicator, bytes, true);
 }
 
 InputStreamPtr
 Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
                        const EncodingVersion& v)
 {
-    return new InputStreamI(communicator, bytes, v);
+    return createInputStream(communicator, bytes, v, true);
+}
+
+InputStreamPtr
+Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
+                       bool copyBytes)
+{
+    return new InputStreamI(communicator, bytes, copyBytes);
+}
+
+InputStreamPtr
+Ice::createInputStream(const CommunicatorPtr& communicator, const pair<const Ice::Byte*, const Ice::Byte*>& bytes,
+                       const EncodingVersion& v, bool copyBytes)
+{
+    return new InputStreamI(communicator, bytes, v, copyBytes);
 }
 
 OutputStreamPtr
diff --git a/cpp/src/Ice/StreamI.cpp b/cpp/src/Ice/StreamI.cpp
index 5df5ec83b38..d204bba06bb 100644
--- a/cpp/src/Ice/StreamI.cpp
+++ b/cpp/src/Ice/StreamI.cpp
@@ -83,49 +83,21 @@ UserExceptionReader::__read(BasicStream* is)
 //
 // InputStreamI
 //
-InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const vector<Byte>& data) :
+InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data, 
+                           bool copyData) :
     _communicator(communicator),
     _closure(0)
 {
     Instance* instance = getInstance(communicator).get();
-    _is = new BasicStream(instance, instance->defaultsAndOverrides()->defaultEncoding, true);
-    _is->closure(this);
-    _is->writeBlob(data);
-    _is->i = _is->b.begin();
-}
-
-InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const vector<Byte>& data, const EncodingVersion& v) :
-    _communicator(communicator),
-    _closure(0)
-{
-    Instance* instance = getInstance(communicator).get();
-    _is = new BasicStream(instance, v, true);
-    _is->closure(this);
-    _is->writeBlob(data);
-    _is->i = _is->b.begin();
-}
-
-InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data) :
-    _communicator(communicator),
-    _closure(0)
-{
-    Instance* instance = getInstance(communicator).get();
-    _is = new BasicStream(instance, instance->defaultsAndOverrides()->defaultEncoding, true);
-    _is->closure(this);
-    _is->writeBlob(data.first, data.second - data.first);
-    _is->i = _is->b.begin();
+    initialize(instance, data, instance->defaultsAndOverrides()->defaultEncoding, copyData);
 }
 
 InputStreamI::InputStreamI(const CommunicatorPtr& communicator, const pair<const Byte*, const Byte*>& data,
-                           const EncodingVersion& v) :
+                           const EncodingVersion& v, bool copyData) :
     _communicator(communicator),
     _closure(0)
 {
-    Instance* instance = getInstance(communicator).get();
-    _is = new BasicStream(instance, v, true);
-    _is->closure(this);
-    _is->writeBlob(data.first, data.second - data.first);
-    _is->i = _is->b.begin();
+    initialize(getInstance(communicator).get(), data, v, copyData);
 }
 
 InputStreamI::~InputStreamI()
@@ -415,6 +387,23 @@ InputStreamI::closure() const
     return _closure;
 }
 
+void
+InputStreamI::initialize(Instance* instance, const pair<const Byte*, const Byte*>& buf, const EncodingVersion& v, 
+                         bool copyData)
+{
+    if(copyData)
+    {
+        _is = new BasicStream(instance, v, true);
+        _is->writeBlob(buf.first, buf.second - buf.first);
+        _is->i = _is->b.begin();
+    }
+    else
+    {
+        _is = new BasicStream(instance, v, buf.first, buf.second);
+    }
+    _is->closure(this);
+}
+
 //
 // OutputStreamI
 //
diff --git a/cpp/src/Ice/StreamI.h b/cpp/src/Ice/StreamI.h
index da1f33cf7e4..f1490faddc2 100644
--- a/cpp/src/Ice/StreamI.h
+++ b/cpp/src/Ice/StreamI.h
@@ -30,10 +30,8 @@ class InputStreamI : public InputStream
 {
 public:
 
-    InputStreamI(const CommunicatorPtr&, const std::vector<Byte>&);
-    InputStreamI(const CommunicatorPtr&, const std::vector<Byte>&, const EncodingVersion&);
-    InputStreamI(const CommunicatorPtr&, const std::pair<const Byte*, const Byte*>&);
-    InputStreamI(const CommunicatorPtr&, const std::pair<const Byte*, const Byte*>&, const EncodingVersion&);
+    InputStreamI(const CommunicatorPtr&, const std::pair<const Byte*, const Byte*>&, bool);
+    InputStreamI(const CommunicatorPtr&, const std::pair<const Byte*, const Byte*>&, const EncodingVersion&, bool);
     virtual ~InputStreamI();
 
     virtual CommunicatorPtr communicator() const;
@@ -102,6 +100,8 @@ public:
 
 private:
 
+    void initialize(IceInternal::Instance*, const std::pair<const Byte*, const Byte*>&, const EncodingVersion&, bool);
+    
     const CommunicatorPtr _communicator;
     IceInternal::BasicStream* _is;
     std::vector< ReadObjectCallbackPtr > _callbacks;
diff --git a/cpp/src/slice2freeze/Main.cpp b/cpp/src/slice2freeze/Main.cpp
index a42d692297c..d16c8213653 100644
--- a/cpp/src/slice2freeze/Main.cpp
+++ b/cpp/src/slice2freeze/Main.cpp
@@ -360,14 +360,11 @@ writeCodecC(const TypePtr& type, const StringList& metaData, const string& name,
       << "const Ice::EncodingVersion& encoding)";
     C << sb;
     C << nl << "IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);";
-    C << nl << "IceInternal::BasicStream stream(instance.get(), encoding, true);";
+    C << nl << "IceInternal::BasicStream stream(instance.get(), encoding, &bytes[0], &bytes[0] + bytes.size());";
     if(type->usesClasses())
     {
         C << nl << "stream.sliceObjects(false);";
     }
-    C << nl << "stream.b.resize(bytes.size());";
-    C << nl << "::memcpy(&stream.b[0], &bytes[0], bytes.size());";
-    C << nl << "stream.i = stream.b.begin();";
     if(encaps)
     {
         C << nl << "stream.startReadEncaps();";
@@ -754,11 +751,9 @@ writeDictWithIndicesC(const string& name, const string& absolute, const Dict& di
         else
         {
             C << nl << "IceInternal::InstancePtr __instance = IceInternal::getInstance(__communicator);";
-            C << nl << "IceInternal::BasicStream __stream(__instance.get(), __encoding, true);";
+            C << nl << "IceInternal::BasicStream __stream(__instance.get(), __encoding, ";
+            C << "&__bytes[0], &__bytes[0] + __bytes.size());";
             
-            C << nl << "__stream.b.resize(__bytes.size());";
-            C << nl << "::memcpy(&__stream.b[0], &__bytes[0], __bytes.size());";
-            C << nl << "__stream.i = __stream.b.begin();";
             writeMarshalUnmarshalCode(C, indexTypes[i].type, false, 0, "__index", false, indexTypes[i].metaData, 0,
                                       "__stream", false);
         }
diff --git a/cpp/src/slice2freezej/Main.cpp b/cpp/src/slice2freezej/Main.cpp
index 183d262b92e..49c0514a2ae 100644
--- a/cpp/src/slice2freezej/Main.cpp
+++ b/cpp/src/slice2freezej/Main.cpp
@@ -930,16 +930,11 @@ FreezeGenerator::generate(UnitPtr& u, const Dict& dict)
             << "(byte[] b, Ice.Communicator communicator, Ice.EncodingVersion encoding)";
         out << sb;
         out << nl << "IceInternal.BasicStream __is = "
-            << "new IceInternal.BasicStream(IceInternal.Util.getInstance(communicator), encoding, true, false);";
+            << "new IceInternal.BasicStream(IceInternal.Util.getInstance(communicator), encoding, b);";
         if(type->usesClasses())
         {
             out << nl << "__is.sliceObjects(false);";
         }
-        out << nl << "__is.resize(b.length, true);";
-        out << nl << "IceInternal.Buffer __buf = __is.getBuffer();";
-        out << nl << "__buf.b.position(0);";
-        out << nl << "__buf.b.put(b);";
-        out << nl << "__buf.b.position(0);";
         if(encaps)
         {
             out << nl << "__is.startReadEncaps();";
@@ -1101,12 +1096,7 @@ FreezeGenerator::generate(UnitPtr& u, const Dict& dict)
         else
         {
             out << nl << "IceInternal.BasicStream __is = "
-                << "new IceInternal.BasicStream(IceInternal.Util.getInstance(communicator), encoding, true, false);";
-            out << nl << "__is.resize(bytes.length, true);";
-            out << nl << "IceInternal.Buffer buf = __is.getBuffer();";
-            out << nl << "buf.b.position(0);";
-            out << nl << "buf.b.put(bytes);";
-            out << nl << "buf.b.position(0);";
+                << "new IceInternal.BasicStream(IceInternal.Util.getInstance(communicator), encoding, bytes);";
 
             int iter = 0;
             list<string> metaData;