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

Backout bug 979445 due to clang build failures. CLOSED TREE

This commit is contained in:
Kyle Huey 2014-03-06 11:19:44 -08:00
Родитель e151bee907
Коммит 2ffecf71ae
9 изменённых файлов: 45 добавлений и 173 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

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

@ -21,7 +21,6 @@
#include "mozilla/dom/quota/FileStreams.h"
#include "mozilla/Endian.h"
#include "mozilla/storage.h"
#include "nsAutoRef.h"
#include "nsContentUtils.h"
#include "nsDOMClassInfo.h"
#include "nsDOMFile.h"
@ -3095,8 +3094,6 @@ NoRequestObjectStoreHelper::OnError()
mTransaction->Abort(GetResultCode());
}
namespace {
// This is a duplicate of the js engine's byte munging in StructuredClone.cpp
uint64_t
ReinterpretDoubleAsUInt64(double d)
@ -3109,15 +3106,6 @@ ReinterpretDoubleAsUInt64(double d)
return pun.u;
}
template <>
class nsAutoRefTraits<char> : public nsPointerRefTraits<char>
{
public:
static void Release(char* ptr) { moz_free(ptr); }
};
} // anonymous namespace
nsresult
AddHelper::DoDatabaseWork(mozIStorageConnection* aConnection)
{
@ -3194,30 +3182,28 @@ AddHelper::DoDatabaseWork(mozIStorageConnection* aConnection)
mKey.BindToStatement(stmt, NS_LITERAL_CSTRING("key_value"));
// Compress the bytes before adding into the database.
const char* uncompressed =
reinterpret_cast<const char*>(mCloneWriteInfo.mCloneBuffer.data());
size_t uncompressedLength = mCloneWriteInfo.mCloneBuffer.nbytes();
static const fallible_t fallible = fallible_t();
size_t compressedLength = snappy::MaxCompressedLength(uncompressedLength);
// moz_malloc is equivalent to NS_Alloc, which we use because mozStorage
// expects to be able to free the adopted pointer with NS_Free.
nsAutoRef<char> compressed((char*)moz_malloc(compressedLength));
// This will hold our compressed data until the end of the method. The
// BindBlobByName function will copy it.
nsAutoArrayPtr<char> compressed(new (fallible) char[compressedLength]);
NS_ENSURE_TRUE(compressed, NS_ERROR_OUT_OF_MEMORY);
snappy::RawCompress(uncompressed, uncompressedLength, compressed,
snappy::RawCompress(uncompressed, uncompressedLength, compressed.get(),
&compressedLength);
uint8_t* dataBuffer = reinterpret_cast<uint8_t*>(compressed.get());
const uint8_t* dataBuffer =
reinterpret_cast<const uint8_t*>(compressed.get());
size_t dataBufferLength = compressedLength;
// If this call succeeds, | compressed | is now owned by mozStorage, and we
// are no longer responsible for it.
rv = stmt->BindAdoptedBlobByName(NS_LITERAL_CSTRING("data"), dataBuffer,
dataBufferLength);
rv = stmt->BindBlobByName(NS_LITERAL_CSTRING("data"), dataBuffer,
dataBufferLength);
IDB_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
compressed.disown();
// Handle blobs
uint32_t length = mCloneWriteInfo.mFiles.Length();

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

@ -907,17 +907,21 @@ public:
rv = aArguments->GetSharedBlob(0, &uncompressedLength, &uncompressed);
NS_ENSURE_SUCCESS(rv, rv);
static const fallible_t fallible = fallible_t();
size_t compressedLength = snappy::MaxCompressedLength(uncompressedLength);
char* compressed = (char*)moz_malloc(compressedLength);
nsAutoArrayPtr<char> compressed(new (fallible) char[compressedLength]);
NS_ENSURE_TRUE(compressed, NS_ERROR_OUT_OF_MEMORY);
snappy::RawCompress(reinterpret_cast<const char*>(uncompressed),
uncompressedLength, compressed, &compressedLength);
uncompressedLength, compressed.get(),
&compressedLength);
std::pair<uint8_t *, int> data((uint8_t*)compressed,
int(compressedLength));
// The variant takes ownership of | compressed |.
nsCOMPtr<nsIVariant> result = new mozilla::storage::AdoptedBlobVariant(data);
std::pair<const void *, int> data(static_cast<void*>(compressed.get()),
int(compressedLength));
// XXX This copies the buffer again... There doesn't appear to be any way to
// preallocate space and write directly to a BlobVariant at the moment.
nsCOMPtr<nsIVariant> result = new mozilla::storage::BlobVariant(data);
result.forget(aResult);
return NS_OK;

2
storage/public/mozIStorageAsyncStatement.idl
Просмотреть файл

@ -16,7 +16,7 @@
* consequently can cause the main thread to lock for extended intervals while
* the asynchronous thread performs some long-running operation.
*/
[scriptable, uuid(52e49370-3b2e-4a27-a3fc-79e20ad4056b)]
[scriptable, uuid(2400f64d-2cb3-49a9-b01e-f03cacb8aa6e)]
interface mozIStorageAsyncStatement : mozIStorageBaseStatement {
/*
* 'params' provides a magic JS helper that lets you assign parameters by

6
storage/public/mozIStorageBaseStatement.idl
Просмотреть файл

@ -19,7 +19,7 @@ interface mozIStorageBindingParamsArray;
* (mozIStorageStatement) that can be used for both synchronous and asynchronous
* purposes.
*/
[scriptable, uuid(5d34f333-ed3f-4aa2-ba51-f2a8b0cfa33a)]
[scriptable, uuid(da2ec336-fbbb-4ba1-9778-8c9825980d01)]
interface mozIStorageBaseStatement : mozIStorageBindingParams {
/**
* Finalizes a statement so you can successfully close a database connection.
@ -67,10 +67,6 @@ interface mozIStorageBaseStatement : mozIStorageBindingParams {
in unsigned long aParamIndex,
[array,const,size_is(aValueSize)] in octet aValue,
in unsigned long aValueSize);
[deprecated] void bindAdoptedBlobParameter(
in unsigned long aParamIndex,
[array,size_is(aValueSize)] in octet aValue,
in unsigned long aValueSize);
/**@}*/
/**

16
storage/public/mozIStorageBindingParams.idl
Просмотреть файл

@ -8,7 +8,7 @@
interface nsIVariant;
[scriptable, uuid(7d8763ad-79d9-4674-ada1-37fd702af68c)]
[scriptable, uuid(a8d4827c-641c-45e3-a9ea-493570b4106b)]
interface mozIStorageBindingParams : nsISupports {
/**
* Binds aValue to the parameter with the name aName.
@ -34,13 +34,6 @@ interface mozIStorageBindingParams : nsISupports {
void bindBlobByName(in AUTF8String aName,
[array, const, size_is(aValueSize)] in octet aValue,
in unsigned long aValueSize);
// The function adopts the storage for the provided blob. After calling
// this function, mozStorage will ensure that NS_Free is called on the
// underlying pointer.
[noscript]
void bindAdoptedBlobByName(in AUTF8String aName,
[array, size_is(aValueSize)] in octet aValue,
in unsigned long aValueSize);
/**
* Binds aValue to the parameter with the index aIndex.
@ -66,11 +59,4 @@ interface mozIStorageBindingParams : nsISupports {
void bindBlobByIndex(in unsigned long aIndex,
[array, const, size_is(aValueSize)] in octet aValue,
in unsigned long aValueSize);
// The function adopts the storage for the provided blob. After calling
// this function, mozStorage will ensure that NS_Free is called on the
// underlying pointer.
[noscript]
void bindAdoptedBlobByIndex(in unsigned long aIndex,
[array, size_is(aValueSize)] in octet aValue,
in unsigned long aValueSize);
};

2
storage/public/mozIStorageStatement.idl
Просмотреть файл

@ -15,7 +15,7 @@
* A SQL statement that can be used for both synchronous and asynchronous
* purposes.
*/
[scriptable, uuid(b3c4476e-c490-4e3b-9db1-e2d3a6f0287c)]
[scriptable, uuid(57ec7be1-36cf-4510-b938-7d1c9ee8cec5)]
interface mozIStorageStatement : mozIStorageBaseStatement {
/**
* Create a clone of this statement, by initializing a new statement

9
storage/src/StorageBaseStatementInternal.h
Просмотреть файл

@ -319,15 +319,6 @@ NS_DEFINE_STATIC_IID_ACCESSOR(StorageBaseStatementInternal,
(uint32_t aWhere, \
const uint8_t *aValue, \
uint32_t aValueSize), \
(aWhere, aValue, aValueSize)) \
BIND_GEN_IMPL(_class, _optionalGuard, \
AdoptedBlob, \
(const nsACString &aWhere, \
uint8_t *aValue, \
uint32_t aValueSize), \
(uint32_t aWhere, \
uint8_t *aValue, \
uint32_t aValueSize), \
(aWhere, aValue, aValueSize))

104
storage/src/Variant.h
Просмотреть файл

@ -54,7 +54,7 @@ struct variant_traits
static inline uint16_t type() { return nsIDataType::VTYPE_EMPTY; }
};
template <typename DataType, bool Adopting=false>
template <typename DataType>
struct variant_storage_traits
{
typedef DataType ConstructorType;
@ -63,40 +63,37 @@ struct variant_storage_traits
{
*_storage = aData;
}
static inline void destroy(const StorageType& _storage)
{ }
};
#define NO_CONVERSION return NS_ERROR_CANNOT_CONVERT_DATA;
template <typename DataType, bool Adopting=false>
template <typename DataType>
struct variant_integer_traits
{
typedef typename variant_storage_traits<DataType, Adopting>::StorageType StorageType;
typedef typename variant_storage_traits<DataType>::StorageType StorageType;
static inline nsresult asInt32(const StorageType &, int32_t *) { NO_CONVERSION }
static inline nsresult asInt64(const StorageType &, int64_t *) { NO_CONVERSION }
};
template <typename DataType, bool Adopting=false>
template <typename DataType>
struct variant_float_traits
{
typedef typename variant_storage_traits<DataType, Adopting>::StorageType StorageType;
typedef typename variant_storage_traits<DataType>::StorageType StorageType;
static inline nsresult asDouble(const StorageType &, double *) { NO_CONVERSION }
};
template <typename DataType, bool Adopting=false>
template <typename DataType>
struct variant_text_traits
{
typedef typename variant_storage_traits<DataType, Adopting>::StorageType StorageType;
typedef typename variant_storage_traits<DataType>::StorageType StorageType;
static inline nsresult asUTF8String(const StorageType &, nsACString &) { NO_CONVERSION }
static inline nsresult asString(const StorageType &, nsAString &) { NO_CONVERSION }
};
template <typename DataType, bool Adopting=false>
template <typename DataType>
struct variant_blob_traits
{
typedef typename variant_storage_traits<DataType, Adopting>::StorageType StorageType;
typedef typename variant_storage_traits<DataType>::StorageType StorageType;
static inline nsresult asArray(const StorageType &, uint16_t *, uint32_t *, void **)
{ NO_CONVERSION }
};
@ -181,8 +178,6 @@ struct variant_storage_traits<nsString>
{
*_outData = aText;
}
static inline void destroy(const StorageType& _outData)
{ }
};
template < >
struct variant_text_traits<nsString>
@ -215,8 +210,6 @@ struct variant_storage_traits<nsCString>
{
*_outData = aText;
}
static inline void destroy(const StorageType &aData)
{ }
};
template < >
struct variant_text_traits<nsCString>
@ -245,7 +238,7 @@ struct variant_traits<uint8_t[]>
static inline uint16_t type() { return nsIDataType::VTYPE_ARRAY; }
};
template < >
struct variant_storage_traits<uint8_t[], false>
struct variant_storage_traits<uint8_t[]>
{
typedef std::pair<const void *, int> ConstructorType;
typedef FallibleTArray<uint8_t> StorageType;
@ -256,28 +249,9 @@ struct variant_storage_traits<uint8_t[], false>
(void)_outData->AppendElements(static_cast<const uint8_t *>(aBlob.first),
aBlob.second);
}
static inline void destroy(const StorageType& _outData)
{ }
};
template < >
struct variant_storage_traits<uint8_t[], true>
{
typedef std::pair<uint8_t *, int> ConstructorType;
typedef std::pair<uint8_t *, int> StorageType;
static inline void storage_conversion(ConstructorType aBlob, StorageType* _outData)
{
*_outData = aBlob;
}
static inline void destroy(StorageType &aData)
{
if (aData.first) {
NS_Free(aData.first);
aData.first = nullptr;
}
}
};
template < >
struct variant_blob_traits<uint8_t[], false>
struct variant_blob_traits<uint8_t[]>
{
static inline nsresult asArray(FallibleTArray<uint8_t> &aData,
uint16_t *_type,
@ -303,34 +277,6 @@ struct variant_blob_traits<uint8_t[], false>
}
};
template < >
struct variant_blob_traits<uint8_t[], true>
{
static inline nsresult asArray(std::pair<uint8_t *, int> &aData,
uint16_t *_type,
uint32_t *_size,
void **_result)
{
// For empty blobs, we return nullptr.
if (aData.second == 0) {
*_result = nullptr;
*_type = nsIDataType::VTYPE_UINT8;
*_size = 0;
return NS_OK;
}
// Otherwise, transfer the data out.
*_result = aData.first;
aData.first = nullptr;
MOZ_ASSERT(*_result); // We asked for it twice, better not use adopting!
// Set type and size
*_type = nsIDataType::VTYPE_UINT8;
*_size = aData.second;
return NS_OK;
}
};
/**
* nullptr type
*/
@ -365,18 +311,13 @@ public:
////////////////////////////////////////////////////////////////////////////////
//// Template Implementation
template <typename DataType, bool Adopting=false>
template <typename DataType>
class Variant : public Variant_base
{
~Variant()
{
variant_storage_traits<DataType, Adopting>::destroy(mData);
}
public:
Variant(const typename variant_storage_traits<DataType, Adopting>::ConstructorType aData)
Variant(const typename variant_storage_traits<DataType>::ConstructorType aData)
{
variant_storage_traits<DataType, Adopting>::storage_conversion(aData, &mData);
variant_storage_traits<DataType>::storage_conversion(aData, &mData);
}
NS_IMETHOD GetDataType(uint16_t *_type)
@ -386,27 +327,27 @@ public:
}
NS_IMETHOD GetAsInt32(int32_t *_integer)
{
return variant_integer_traits<DataType, Adopting>::asInt32(mData, _integer);
return variant_integer_traits<DataType>::asInt32(mData, _integer);
}
NS_IMETHOD GetAsInt64(int64_t *_integer)
{
return variant_integer_traits<DataType, Adopting>::asInt64(mData, _integer);
return variant_integer_traits<DataType>::asInt64(mData, _integer);
}
NS_IMETHOD GetAsDouble(double *_double)
{
return variant_float_traits<DataType, Adopting>::asDouble(mData, _double);
return variant_float_traits<DataType>::asDouble(mData, _double);
}
NS_IMETHOD GetAsAUTF8String(nsACString &_str)
{
return variant_text_traits<DataType, Adopting>::asUTF8String(mData, _str);
return variant_text_traits<DataType>::asUTF8String(mData, _str);
}
NS_IMETHOD GetAsAString(nsAString &_str)
{
return variant_text_traits<DataType, Adopting>::asString(mData, _str);
return variant_text_traits<DataType>::asString(mData, _str);
}
NS_IMETHOD GetAsArray(uint16_t *_type,
@ -414,11 +355,11 @@ public:
uint32_t *_size,
void **_data)
{
return variant_blob_traits<DataType, Adopting>::asArray(mData, _type, _size, _data);
return variant_blob_traits<DataType>::asArray(mData, _type, _size, _data);
}
private:
typename variant_storage_traits<DataType, Adopting>::StorageType mData;
typename variant_storage_traits<DataType>::StorageType mData;
};
////////////////////////////////////////////////////////////////////////////////
@ -428,8 +369,7 @@ typedef Variant<int64_t> IntegerVariant;
typedef Variant<double> FloatVariant;
typedef Variant<nsString> TextVariant;
typedef Variant<nsCString> UTF8TextVariant;
typedef Variant<uint8_t[], false> BlobVariant;
typedef Variant<uint8_t[], true> AdoptedBlobVariant;
typedef Variant<uint8_t[]> BlobVariant;
} // namespace storage
} // namespace mozilla

31
storage/src/mozStorageBindingParams.cpp
Просмотреть файл

@ -354,22 +354,6 @@ BindingParams::BindBlobByName(const nsACString &aName,
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindAdoptedBlobByName(const nsACString &aName,
uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<uint8_t *, int> data(
aValue,
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
return BindByName(aName, value);
}
NS_IMETHODIMP
BindingParams::BindByIndex(uint32_t aIndex,
nsIVariant *aValue)
@ -472,20 +456,5 @@ BindingParams::BindBlobByIndex(uint32_t aIndex,
return BindByIndex(aIndex, value);
}
NS_IMETHODIMP
BindingParams::BindAdoptedBlobByIndex(uint32_t aIndex,
uint8_t *aValue,
uint32_t aValueSize)
{
NS_ENSURE_ARG_MAX(aValueSize, INT_MAX);
std::pair<uint8_t *, int> data(
static_cast<uint8_t *>(aValue),
int(aValueSize)
);
nsCOMPtr<nsIVariant> value(new AdoptedBlobVariant(data));
return BindByIndex(aIndex, value);
}
} // namespace storage
} // namespace mozilla