Merge from TFS

Author: ras0219-msft

Release/include/cpprest/astreambuf.h

@@ -418,11 +418,15 @@ namespace Concurrency { namespace streams
                 closeOp = _close_read();
             }
 
+            // After the flush_internal task completed, "this" object may have been destroyed, 
+            // accessing the memebers is invalid, use shared_from_this to avoid access violation exception.
+            auto this_ptr = std::static_pointer_cast<streambuf_state_manager>(this->shared_from_this());
+
             if (mode & std::ios_base::out && can_write()) {
                 if (closeOp.is_done())
-                    closeOp = closeOp && _close_write(); // passing down exceptions from closeOp
+                    closeOp = closeOp && _close_write().then([this_ptr]{}); // passing down exceptions from closeOp
                 else
-                    closeOp = closeOp.then([this] { return _close_write();});
+                    closeOp = closeOp.then([this_ptr] { return this_ptr->_close_write().then([this_ptr]{}); });
             }
 
             return closeOp;

Release/include/cpprest/filestream.h

@@ -112,8 +112,14 @@ namespace details {
         typedef typename basic_streambuf<_CharType>::off_type off_type;
 
         virtual ~basic_file_buffer() {
-            if( this->can_read() || this->can_write() ) {
-                this->close().wait();
+            if( this->can_read() )
+            {
+                this->_close_read().wait();
+            }
+
+            if (this->can_write())
+            {
+                this->_close_write().wait();
             }
         }
     protected:

Release/nuget/cpprestsdk.autopkg

@@ -68,7 +68,7 @@ nuget {
 			symbols:${BIN_DIR}Win32\Release\cpprest110_wp8_${VER_WUNDERSCORE}.pdb;
 			lib:${BIN_DIR}Win32\Release\cpprest110_wp8_${VER_WUNDERSCORE}.lib;
 		}
-        
+
         // XP
         [x64,v110_xp,debug,desktop] { 
 			lib: ${BIN_DIR}x64\Debug\cpprest110d_xp_${VER_WUNDERSCORE}.lib;
@@ -93,6 +93,31 @@ nuget {
 			symbols: ${BIN_DIR}Win32\Release\cpprest110_xp_${VER_WUNDERSCORE}.pdb;
 			bin: ${X86_DLLS}cpprest110_xp_${VER_WUNDERSCORE}.dll;
 		}
+
+        // XP vs2013
+		[x64,v120_xp,debug,desktop] { 
+			lib: ${BIN_DIR}x64\Debug\cpprest120d_xp_${VER_WUNDERSCORE}.lib;
+			symbols: ${BIN_DIR}x64\Debug\cpprest120d_xp_${VER_WUNDERSCORE}.pdb;
+			bin: ${X64_DLLS}cpprest120d_xp_${VER_WUNDERSCORE}.dll;
+		}
+		
+		[x86,v120_xp,debug,desktop] { 
+			lib: ${BIN_DIR}Win32\Debug\cpprest120d_xp_${VER_WUNDERSCORE}.lib;
+			symbols: ${BIN_DIR}Win32\Debug\cpprest120d_xp_${VER_WUNDERSCORE}.pdb;
+			bin: ${X86_DLLS}cpprest120d_xp_${VER_WUNDERSCORE}.dll;
+		}
+		
+		[x64,v120_xp,release,desktop] { 
+			lib: ${BIN_DIR}x64\Release\cpprest120_xp_${VER_WUNDERSCORE}.lib;
+			symbols: ${BIN_DIR}x64\Release\cpprest120_xp_${VER_WUNDERSCORE}.pdb;
+			bin: ${X64_DLLS}cpprest120_xp_${VER_WUNDERSCORE}.dll;
+		}	
+
+		[x86,v120_xp,release,desktop] { 
+			lib: ${BIN_DIR}Win32\Release\cpprest120_xp_${VER_WUNDERSCORE}.lib;
+			symbols: ${BIN_DIR}Win32\Release\cpprest120_xp_${VER_WUNDERSCORE}.pdb;
+			bin: ${X86_DLLS}cpprest120_xp_${VER_WUNDERSCORE}.dll;
+		}
 
 		[x64,v110,debug,desktop] { 
 			lib: ${BIN_DIR}x64\Debug\cpprest110d_${VER_WUNDERSCORE}.lib;

Release/tests/Functional/streams/fstreambuf_tests.cpp

@@ -944,6 +944,54 @@ TEST(alloc_acquire_not_supported)
     VERIFY_IS_FALSE(file_buf.acquire(temp, size));
 }
 
+TEST(read_alloc_acquire_not_supported)
+{
+    auto file_buf1 = OPEN<char>(U("read_acquire_not_supported1.txt"), std::ios::out | std::ios::in).get();
+    auto file_buf2 = OPEN<char>(U("read_acquire_not_supported2.txt"), std::ios::out | std::ios::in).get();
+
+    concurrency::streams::stringstreambuf data_buf("A");
+    file_buf1.create_ostream().write(data_buf, 1).wait();
+    file_buf1.sync().wait();
+    file_buf2.create_ostream().write(file_buf1, 1).wait();
+    file_buf2.sync().wait();
+
+    file_buf2.create_istream().read(file_buf1, 1).wait();
+    file_buf1.sync().wait();
+    file_buf1.seekpos(0, std::ios::in);
+    data_buf = concurrency::streams::stringstreambuf();
+    file_buf1.create_istream().read(data_buf, 2).wait();
+    const auto &data = data_buf.collection();
+    VERIFY_ARE_EQUAL(data[0], 'A');
+    VERIFY_ARE_EQUAL(data[1], 'A');
+
+    file_buf1.close().wait();
+    file_buf2.close().wait();
+}
+
+TEST(winrt_filestream_close)
+{
+    std::string str("test data");
+    auto t = OPEN_W<uint8_t>(U("file.txt")).then(
+        [this, str](concurrency::streams::ostream stream)
+    {
+        concurrency::streams::container_buffer<std::string> rbuf(str);
+        concurrency::streams::istream is(rbuf);
+        size_t size = 0;
+        is.read(stream.streambuf(), 1).wait();
+        while (!is.is_eof())
+        {
+            is.read(stream.streambuf(), 1).wait();
+            size += 1;
+        }
+
+        return stream.flush().then([size, stream](){
+            stream.close();
+            return size;
+        });
+    });
+
+    VERIFY_ARE_EQUAL(t.get(), str.length());
+}
 } // SUITE(file_buffer_tests)
 
 }}}