mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out changeset 57e78c503c4e (bug 1294450) for build bustage a=backout

This commit is contained in:
Wes Kocher 2016-09-28 17:38:00 -07:00
Родитель a07d259ed7
Коммит 673a0db365
11 изменённых файлов: 3 добавлений и 164 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

12
dom/indexedDB/FileSnapshot.cpp
Просмотреть файл

@ -282,18 +282,6 @@ StreamWrapper::Deserialize(const InputStreamParams& aParams,
return false;
}
Maybe<uint64_t>
StreamWrapper::ExpectedSerializedLength()
{
nsCOMPtr<nsIIPCSerializableInputStream> stream =
do_QueryInterface(mInputStream);
if (stream) {
return stream->ExpectedSerializedLength();
}
return Nothing();
}
NS_IMPL_ISUPPORTS_INHERITED0(StreamWrapper::CloseRunnable,
Runnable)

6
dom/ipc/Blob.cpp
Просмотреть файл

@ -1307,12 +1307,6 @@ RemoteInputStream::Deserialize(const InputStreamParams& /* aParams */,
MOZ_CRASH("RemoteInputStream should never be deserialized");
}
Maybe<uint64_t>
RemoteInputStream::ExpectedSerializedLength()
{
return Nothing();
}
nsIInputStream*
RemoteInputStream::BlockAndGetInternalStream()
{

31
ipc/glue/IPCStreamUtils.cpp
Просмотреть файл

@ -20,9 +20,6 @@
#include "mozilla/ipc/SendStream.h"
#include "mozilla/Unused.h"
#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
#include "nsIPipe.h"
#include "nsStreamUtils.h"
namespace mozilla {
namespace ipc {
@ -125,41 +122,17 @@ SerializeInputStream(nsIInputStream* aStream, IPCStream& aValue, M* aManager)
MOZ_ASSERT(aStream);
MOZ_ASSERT(aManager);
// If a stream is known to be larger than 1MB, prefer sending it in chunks.
const uint64_t kTooLargeStream = 1024 * 1024;
// First attempt simple stream serialization
nsCOMPtr<nsIIPCSerializableInputStream> serializable =
do_QueryInterface(aStream);
uint64_t expectedLength =
serializable ? serializable->ExpectedSerializedLength().valueOr(0) : 0;
if (serializable && expectedLength < kTooLargeStream) {
if (serializable) {
SerializeInputStreamWithFdsChild(aStream, aValue, aManager);
return;
}
// As a fallback, attempt to stream the data across using a SendStream
// actor. For blocking streams, create a nonblocking pipe instead,
// actor. This will fail for blocking streams.
nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(aStream);
if (!asyncStream) {
const uint32_t kBufferSize = 32768; // matches SendStream buffer size.
nsCOMPtr<nsIAsyncOutputStream> sink;
nsresult rv = NS_NewPipe2(getter_AddRefs(asyncStream),
getter_AddRefs(sink),
true,
false,
kBufferSize,
UINT32_MAX);
MOZ_ASSERT(NS_SUCCEEDED(rv));
nsCOMPtr<nsIEventTarget> target =
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
rv = NS_AsyncCopy(aStream, sink, target, NS_ASYNCCOPY_VIA_READSEGMENTS, kBufferSize);
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
MOZ_ASSERT(asyncStream);
aValue = SendStreamChild::Create(asyncStream, aManager);
if (!aValue.get_PSendStreamChild()) {

29
ipc/glue/nsIIPCSerializableInputStream.h
Просмотреть файл

@ -8,7 +8,6 @@
#define mozilla_ipc_nsIIPCSerializableInputStream_h
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"
#include "nsISupports.h"
#include "nsTArrayForwardDeclare.h"
@ -39,17 +38,6 @@ public:
virtual bool
Deserialize(const mozilla::ipc::InputStreamParams& aParams,
const FileDescriptorArray& aFileDescriptors) = 0;
// The number of bytes that are expected to be written when this
// stream is serialized. A value of Some(N) indicates that N bytes
// will be written to the IPC buffer, and will be used to decide
// upon an optimal transmission mechanism. A value of Nothing
// indicates that either serializing this stream will not require
// serializing its contents (eg. a file-backed stream, or a stream
// backed by an IPC actor), or the length of the stream's contents
// cannot be determined.
virtual mozilla::Maybe<uint64_t>
ExpectedSerializedLength() = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
@ -62,10 +50,7 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
\
virtual bool \
Deserialize(const mozilla::ipc::InputStreamParams&, \
const FileDescriptorArray&) override; \
\
virtual mozilla::Maybe<uint64_t> \
ExpectedSerializedLength() override;
const FileDescriptorArray&) override;
#define NS_FORWARD_NSIIPCSERIALIZABLEINPUTSTREAM(_to) \
virtual void \
@ -80,12 +65,6 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
const FileDescriptorArray& aFileDescriptors) override \
{ \
return _to Deserialize(aParams, aFileDescriptors); \
} \
\
virtual mozilla::Maybe<uint64_t> \
ExpectedSerializedLength() override \
{ \
return _to ExpectedSerializedLength(); \
}
#define NS_FORWARD_SAFE_NSIIPCSERIALIZABLEINPUTSTREAM(_to) \
@ -103,12 +82,6 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
const FileDescriptorArray& aFileDescriptors) override \
{ \
return _to ? _to->Deserialize(aParams, aFileDescriptors) : false; \
} \
\
virtual mozilla::Maybe<uint64_t> \
ExpectedSerializedLength() override \
{ \
return _to ? _to->ExpectedSerializedLength() : Nothing(); \
}
#endif // mozilla_ipc_nsIIPCSerializableInputStream_h

13
netwerk/base/nsBufferedStreams.cpp
Просмотреть файл

@ -38,9 +38,6 @@ static struct {
#endif
using namespace mozilla::ipc;
using mozilla::Maybe;
using mozilla::Nothing;
using mozilla::Some;
////////////////////////////////////////////////////////////////////////////////
// nsBufferedStream
@ -544,16 +541,6 @@ nsBufferedInputStream::Deserialize(const InputStreamParams& aParams,
return true;
}
Maybe<uint64_t>
nsBufferedInputStream::ExpectedSerializedLength()
{
nsCOMPtr<nsIIPCSerializableInputStream> stream = do_QueryInterface(mStream);
if (stream) {
return stream->ExpectedSerializedLength();
}
return Nothing();
}
////////////////////////////////////////////////////////////////////////////////
// nsBufferedOutputStream

16
netwerk/base/nsFileStreams.cpp
Просмотреть файл

@ -32,9 +32,6 @@ typedef mozilla::ipc::FileDescriptor::PlatformHandleType FileHandleType;
using namespace mozilla::ipc;
using mozilla::DebugOnly;
using mozilla::Maybe;
using mozilla::Nothing;
using mozilla::Some;
////////////////////////////////////////////////////////////////////////////////
// nsFileStreamBase
@ -665,12 +662,6 @@ nsFileInputStream::Deserialize(const InputStreamParams& aParams,
return true;
}
Maybe<uint64_t>
nsFileInputStream::ExpectedSerializedLength()
{
return Nothing();
}
////////////////////////////////////////////////////////////////////////////////
// nsPartialFileInputStream
@ -869,13 +860,6 @@ nsPartialFileInputStream::Deserialize(
return NS_SUCCEEDED(nsFileInputStream::Seek(NS_SEEK_SET, mStart));
}
Maybe<uint64_t>
nsPartialFileInputStream::ExpectedSerializedLength()
{
return Some(mLength);
}
nsresult
nsPartialFileInputStream::DoPendingSeek()
{

9
netwerk/base/nsMIMEInputStream.cpp
Просмотреть файл

@ -23,7 +23,6 @@
#include "mozilla/ipc/InputStreamUtils.h"
using namespace mozilla::ipc;
using mozilla::Maybe;
class nsMIMEInputStream : public nsIMIMEInputStream,
public nsISeekableStream,
@ -380,11 +379,3 @@ nsMIMEInputStream::Deserialize(const InputStreamParams& aParams,
return true;
}
Maybe<uint64_t>
nsMIMEInputStream::ExpectedSerializedLength()
{
nsCOMPtr<nsIIPCSerializableInputStream> serializable = do_QueryInterface(mStream);
return serializable ? serializable->ExpectedSerializedLength() : Nothing();
}

6
netwerk/base/nsTemporaryFileInputStream.cpp
Просмотреть файл

@ -239,9 +239,3 @@ nsTemporaryFileInputStream::Deserialize(const InputStreamParams& aParams,
mEndPos = params.endPos();
return true;
}
Maybe<uint64_t>
nsTemporaryFileInputStream::ExpectedSerializedLength()
{
return Nothing();
}

26
xpcom/io/nsMultiplexInputStream.cpp
Просмотреть файл

@ -29,9 +29,6 @@ using namespace mozilla;
using namespace mozilla::ipc;
using mozilla::DeprecatedAbs;
using mozilla::Maybe;
using mozilla::Nothing;
using mozilla::Some;
class nsMultiplexInputStream final
: public nsIMultiplexInputStream
@ -750,29 +747,6 @@ nsMultiplexInputStream::Deserialize(const InputStreamParams& aParams,
return true;
}
Maybe<uint64_t>
nsMultiplexInputStream::ExpectedSerializedLength()
{
MutexAutoLock lock(mLock);
bool lengthValueExists = false;
uint64_t expectedLength = 0;
uint32_t streamCount = mStreams.Length();
for (uint32_t index = 0; index < streamCount; index++) {
nsCOMPtr<nsIIPCSerializableInputStream> stream = do_QueryInterface(mStreams[index]);
if (!stream) {
continue;
}
Maybe<uint64_t> length = stream->ExpectedSerializedLength();
if (length.isNothing()) {
continue;
}
lengthValueExists = true;
expectedLength += length.value();
}
return lengthValueExists ? Some(expectedLength) : Nothing();
}
NS_IMETHODIMP
nsMultiplexInputStream::GetCloneable(bool* aCloneable)
{

11
xpcom/io/nsStorageStream.cpp
Просмотреть файл

@ -29,8 +29,6 @@
using mozilla::ipc::InputStreamParams;
using mozilla::ipc::StringInputStreamParams;
using mozilla::Maybe;
using mozilla::Some;
//
// Log module for StorageStream logging...
@ -600,15 +598,6 @@ nsStorageInputStream::Serialize(InputStreamParams& aParams, FileDescriptorArray&
aParams = params;
}
Maybe<uint64_t>
nsStorageInputStream::ExpectedSerializedLength()
{
uint64_t remaining = 0;
DebugOnly<nsresult> rv = Available(&remaining);
MOZ_ASSERT(NS_SUCCEEDED(rv));
return Some(remaining);
}
bool
nsStorageInputStream::Deserialize(const InputStreamParams& aParams,
const FileDescriptorArray&)

8
xpcom/io/nsStringStream.cpp
Просмотреть файл

@ -25,8 +25,6 @@
#include "nsIIPCSerializableInputStream.h"
using namespace mozilla::ipc;
using mozilla::Maybe;
using mozilla::Some;
//-----------------------------------------------------------------------------
// nsIStringInputStream implementation
@ -356,12 +354,6 @@ nsStringInputStream::Deserialize(const InputStreamParams& aParams,
return true;
}
Maybe<uint64_t>
nsStringInputStream::ExpectedSerializedLength()
{
return Some(static_cast<uint64_t>(Length()));
}
/////////
// nsICloneableInputStream implementation
/////////