33178 2010-01-04 12:49:21 -0800 Segmented SharedBuffer: SharedBuffer doesn't have to be a flat memory block 2021-11-16 01:22:14 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 1 yong.li.webkit webkit-unassigned darin dglazkov staikos webkit.review.bot oldest_to_newest 176817 0 yong.li.webkit 2010-01-04 12:49:21 -0800 Currently, SharedBuffer uses Vector<char> as the internal buffer, and stores all resource data in the flat vector. When more resource data comes and the buffer size is not big enough, SharedBuffer will allocate a new buffer, and copy all bytes to the new buffer. The purpose of this bug report is to allow SharedBuffer to use a group of memory segments to store resource data, and also enable image/text decoders to decode from segmented source data. This will reduce peak memory usage and also avoid requests for huge memory blocks. For desktop browsers, it is probably not that helpful, but from my testing, it seems not hurting the performance. I tested segmented SharedBuffer with modified text decoders, jpeg decoder and png decoder against iBench using Safari win32, and the result is segmented SharedBuffer is roughly 1% faster. Patches are coming. 176820 1 45821 yong.li.webkit 2010-01-04 12:56:36 -0800 Created attachment 45821 (1) Make SharedBuffer use segments internally 176823 2 webkit.review.bot 2010-01-04 13:04:48 -0800 Attachment 45821 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/platform/cf/SharedBufferCF.cpp:79: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] Total errors found: 1 176826 3 45821 darin 2010-01-04 13:14:28 -0800 Comment on attachment 45821 (1) Make SharedBuffer use segments internally Looks OK. But with no clients using the getSomeData function, it seems like it's scaffolding for some future work and functions like getSomeData are not tested. And this change will make things less efficient until the major clients adopt. Do you know what adding this temporary extra work does to page loading time? I don't want to get stuck with that. This patch also changes behavior when running out of memory. The new code will abort when running out of memory, whereas the old code would drop data. I think that probably should be changed in a separate patch rather than as a side effect of this one. > +#define SEGMENT_SIZE (0x1000) > +#define SEGMENT_POS_MASK (0x0FFF) > +#define GET_SEGMENT(position) ((position) / SEGMENT_SIZE) > +#define GET_OFF_IN_SEGMENT(globalPosition) ((globalPosition) & SEGMENT_POS_MASK) We use C++ constants and inline functions rather than macros for this sort of thing. > + unsigned posInSegment = GET_OFF_IN_SEGMENT(m_size - m_buffer.size()); We try to avoid abbreviations. The existing code uses "len" but should use "length". And here we would use "position" or "offset" rather than "pos" or "off". > + unsigned toCopy = len < segmentFreeSpace ? len : segmentFreeSpace; It's better to use a noun or adjective for this sort of variable rather than the preposition "to". For example, "bytesToCopy" is probably a good name. > + RefPtr<SharedBuffer> clone(adoptRef(new SharedBuffer())); No need for the parentheses here after SharedBuffer. > + clone->m_size = m_size; > + clone->m_buffer.append(m_buffer.data(), m_buffer.size()); > + clone->m_segments.reserveCapacity(m_segments.size()); > + for (Vector<char*>::const_iterator i = m_segments.begin(); i != m_segments.end(); ++i) { > + char* segment = allocateSegment(); > + memcpy(segment, *i, SEGMENT_SIZE); > + clone->m_segments.append(segment); > + } > + return clone; Why is it a good idea to clone all the segments into separate new segments rather than making a single large segment? > + char* dest = m_buffer.data() + bufferSize; Again, avoid abbreviation if possible. > + unsigned left = m_size - bufferSize; The word "left" is a strange name for this. Maybe bytesLeft would be OK. > + for (Vector<char*>::const_iterator i = m_segments.begin(); i != m_segments.end(); ++i) { We normally use array-style index iteration for vectors. The iterators are just there for things like STL algorithms. > +unsigned SharedBuffer::getSomeData(const char** someData, unsigned pos) const > +{ > + if (hasPlatformData() || m_purgeableBuffer) { > + *someData = data(); > + return size(); > + } The above code seems clearly wrong when pos is non-zero. > + // Calling this function will force internal segmented buffers > + // to be merged into a flat buffer. Use getSomeData() whenever possible > + // for better performance. > const char* data() const; > unsigned size() const; This comment comes before a paragraph of two functions. Please add a blank line. > + // Calling this function will force internal segmented buffers > + // to be merged into a flat buffer. Use getSomeData() whenever possible > + // for better performance. > + const Vector<char> &buffer() const; You should change this to "const Vector<char>& buffer()" -- the existing code was formatted incorrectly. > + // Return the flat data size after "pos". "*data" will be the address > + // Return 0 when no more data left. I suggest using "const char*&" for data instead of "const char**". I don't think the term "flat data size" is clear. > + unsigned getSegment(unsigned position) const; > + unsigned getOffsetInSegment(unsigned globalPosition) const; WebKit code normally does not use "get" in the names of functions that have return values. The above functions should be named segmentIndex() and offsetInSegment(). review- because of multiple issues above. 176830 4 yong.li.webkit 2010-01-04 13:17:25 -0800 (In reply to comment #2) > Attachment 45821 [details] did not pass style-queue: > > Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 > WebCore/platform/cf/SharedBufferCF.cpp:79: Tests for true/false, > null/non-null, and zero/non-zero should all be done without equality > comparisons. [readability/comparison_to_zero] [5] > Total errors found: 1 - ASSERT(m_buffer.size() == 0); + ASSERT(m_size == 0); should be ok? 176832 5 darin 2010-01-04 13:20:19 -0800 (In reply to comment #4) > - ASSERT(m_buffer.size() == 0); > + ASSERT(m_size == 0); > > should be ok? No, the old code had wrong style. Should be ASSERT(!m_size). 176847 6 yong.li.webkit 2010-01-04 13:29:14 -0800 (In reply to comment #3) > (From update of attachment 45821 [details]) > Looks OK. But with no clients using the getSomeData function, it seems like > it's scaffolding for some future work and functions like getSomeData are not > tested. And this change will make things less efficient until the major clients > adopt. I have 3 more patches that make all script decoders, jpeg decoder and png decoder support decoding from segmented SharedBuffer. Will post them soon. > > Do you know what adding this temporary extra work does to page loading time? I > don't want to get stuck with that. Probably it's because it doesn't need extra memory copying. But I'm not sure. I did the test just because I want to make sure it doesn't slow down desktop browsers. > > This patch also changes behavior when running out of memory. The new code will > abort when running out of memory, whereas the old code would drop data. I think > that probably should be changed in a separate patch rather than as a side > effect of this one. The current patch calls fastMalloc and I remember fastMalloc calls abort() upon OOM already. In the future, the allocation of segments can be done in other ways for better performance. We could directly allocate a page of virtual memory although I'm not sure if it helps. Thanks for all suggestions and corrections! I'll modify the code and update the patch soon 176855 7 darin 2010-01-04 13:33:26 -0800 (In reply to comment #6) > (In reply to comment #3) > > (From update of attachment 45821 [details] [details]) > > Looks OK. But with no clients using the getSomeData function, it seems like > > it's scaffolding for some future work and functions like getSomeData are not > > tested. And this change will make things less efficient until the major clients > > adopt. > > I have 3 more patches that make all script decoders, jpeg decoder and png > decoder support decoding from segmented SharedBuffer. Will post them soon. I think that means that after your work image decoding on Mac OS X, iPhone, and some other platforms will be less efficient than it is today, because the image decoder in question is not a script decoder, JPEG decoder, or PNG decoder. > > Do you know what adding this temporary extra work does to page loading time? I > > don't want to get stuck with that. > > Probably it's because it doesn't need extra memory copying. But I'm not sure. I > did the test just because I want to make sure it doesn't slow down desktop > browsers. Sorry, I don't understand. This patch will allocate separate segments and then merge them later, which will make things slower for clients that use it the old way. That seems like it will make things slower and will require allocating two copies of everything at one point. You say "did the test". What test did you do? > > This patch also changes behavior when running out of memory. The new code will > > abort when running out of memory, whereas the old code would drop data. I think > > that probably should be changed in a separate patch rather than as a side > > effect of this one. > > The current patch calls fastMalloc and I remember fastMalloc calls abort() upon > OOM already. In the future, the allocation of segments can be done in other > ways for better performance. We could directly allocate a page of virtual > memory although I'm not sure if it helps. Yes, that's just the problem. The old code calls Vector::append, which does not call abort. There is tryFastMalloc, which does not call abort. You could use that and keep the semantics the same. Or you could change the semantics if you think there is a good reason. 176872 8 yong.li.webkit 2010-01-04 14:27:05 -0800 (In reply to comment #7) > (In reply to comment #6) > > (In reply to comment #3) > > > (From update of attachment 45821 [details] [details] [details]) > > > Looks OK. But with no clients using the getSomeData function, it seems like > > > it's scaffolding for some future work and functions like getSomeData are not > > > tested. And this change will make things less efficient until the major clients > > > adopt. > > > > I have 3 more patches that make all script decoders, jpeg decoder and png > > decoder support decoding from segmented SharedBuffer. Will post them soon. > > I think that means that after your work image decoding on Mac OS X, iPhone, and > some other platforms will be less efficient than it is today, because the image > decoder in question is not a script decoder, JPEG decoder, or PNG decoder. > Still not sure why it will less efficient. Even just merging into a flat consecutive buffer at last can still save memory copy times. Also it shouldn't be difficult to make image decoding work on segments, because the resource from network comes in fragments, and a browser should always be able to decode incomplete image source and be able to continue unfinished decoding job when more data comes. > > > Do you know what adding this temporary extra work does to page loading time? I > > > don't want to get stuck with that. > > > > Probably it's because it doesn't need extra memory copying. But I'm not sure. I > > did the test just because I want to make sure it doesn't slow down desktop > > browsers. > > Sorry, I don't understand. This patch will allocate separate segments and then > merge them later, which will make things slower for clients that use it the old > way. That seems like it will make things slower and will require allocating two > copies of everything at one point. > > You say "did the test". What test did you do? > Even with the old solution, when the buffer grows, it has to allocate 2 copies of everything, and copies all bytes from one to the other. The test I did is with other patches that make many decoders support segmented decoding. And more details: 1. run HTML loading test in iBench once and ignore the result. 2. run HTML loading test in iBench for 3 times continously, and record the results. I know the resources are actually loaded from disk cache. But in this way, the results are very stable. When I "reset Safari" every time before running iBench, I got very unstable and useless results. > > > This patch also changes behavior when running out of memory. The new code will > > > abort when running out of memory, whereas the old code would drop data. I think > > > that probably should be changed in a separate patch rather than as a side > > > effect of this one. > > > > The current patch calls fastMalloc and I remember fastMalloc calls abort() upon > > OOM already. In the future, the allocation of segments can be done in other > > ways for better performance. We could directly allocate a page of virtual > > memory although I'm not sure if it helps. > > Yes, that's just the problem. The old code calls Vector::append, which does not > call abort. There is tryFastMalloc, which does not call abort. You could use > that and keep the semantics the same. Or you could change the semantics if you > think there is a good reason. But Vector doesn't call tryFastMalloc, instead, it calls fastMalloc in allocateBuffer(). Have I missed anything? 176875 9 45830 yong.li.webkit 2010-01-04 14:34:27 -0800 Created attachment 45830 (1) make SharedBuffer use segments internally Fixed style problems and bugs that Darin Adler pointed out. 176883 10 webkit.review.bot 2010-01-04 14:43:38 -0800 Attachment 45830 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/platform/cf/SharedBufferCF.cpp:79: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] Total errors found: 1 176896 11 yong.li.webkit 2010-01-04 15:02:48 -0800 (In reply to comment #10) > Attachment 45830 [details] did not pass style-queue: > > Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 > WebCore/platform/cf/SharedBufferCF.cpp:79: Tests for true/false, > null/non-null, and zero/non-zero should all be done without equality > comparisons. [readability/comparison_to_zero] [5] > Total errors found: 1 oops. forgot this one 176928 12 darin 2010-01-04 15:52:01 -0800 (In reply to comment #8) > Still not sure why it will less efficient. Even just merging into a flat > consecutive buffer at last can still save memory copy times. OK. > Also it shouldn't > be difficult to make image decoding work on segments, because the resource from > network comes in fragments, and a browser should always be able to decode > incomplete image source and be able to continue unfinished decoding job when > more data comes. Yes, I agree. We just have to do it! And in the mean time I don't want things to be worse than before. You've convinced me. > But Vector doesn't call tryFastMalloc, instead, it calls fastMalloc in > allocateBuffer(). Have I missed anything? You're right! I am puzzled, now, by all the places in Vector's code where it says: if (!begin()) return; I thought those were out-of-memory checks. 176930 13 45830 darin 2010-01-04 15:54:05 -0800 Comment on attachment 45830 (1) make SharedBuffer use segments internally > +static unsigned segmentIndex(unsigned position) > +{ > + return position / segmentSize; > +} > + > +static unsigned offsetInSegment(unsigned position) > +{ > + return position & segmentPositionMask; > +} Should probably say "inline" in both of these. > +unsigned SharedBuffer::getSomeData(const char*& someData, unsigned pos) const Would prefer "position" or "offset" to "pos". r=me 177128 14 yong.li.webkit 2010-01-05 06:51:37 -0800 (In reply to comment #13) > (From update of attachment 45830 [details]) > > +static unsigned segmentIndex(unsigned position) > > +{ > > + return position / segmentSize; > > +} > > + > > +static unsigned offsetInSegment(unsigned position) > > +{ > > + return position & segmentPositionMask; > > +} > > Should probably say "inline" in both of these. > > > +unsigned SharedBuffer::getSomeData(const char*& someData, unsigned pos) const > > Would prefer "position" or "offset" to "pos". > > r=me Thanks! I'll fix these before committing it 177140 15 45830 yong.li.webkit 2010-01-05 07:26:34 -0800 Comment on attachment 45830 (1) make SharedBuffer use segments internally committed @ r52795 clear flags 177143 16 45889 yong.li.webkit 2010-01-05 07:31:45 -0800 Created attachment 45889 (2) make PNG image decoder read from segmented SharedBuffer 177144 17 webkit.review.bot 2010-01-05 07:34:57 -0800 style-queue ran check-webkit-style on attachment 45889 without any errors. 177146 18 webkit.review.bot 2010-01-05 07:40:28 -0800 Attachment 45889 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/164099 177147 19 45890 yong.li.webkit 2010-01-05 07:41:05 -0800 Created attachment 45890 Fix a bug in the first commit (introduced when fixing coding style) also include another coding style fix 177148 20 darin 2010-01-05 07:42:53 -0800 I don’t think you should do all the adoption patches in a single bug. It’s confusing. 177154 21 yong.li.webkit 2010-01-05 07:58:15 -0800 (In reply to comment #20) > I don’t think you should do all the adoption patches in a single bug. It’s > confusing. OK. I'll raise new bugs 177167 22 darin 2010-01-05 08:36:39 -0800 > unsigned bytesToCopy = static_cast<unsigned>(length) < segmentFreeSpace ? static_cast<unsigned>(length) : segmentFreeSpace; A more elegant way to write that is: unsigned bytesToCopy = min<unsigned>(length, segmentFreeSpace); That gets rid of the casts too. In general, the min function is helpful for these "how much more data to get out of a buffer" sites. 177169 23 45894 yong.li.webkit 2010-01-05 08:41:25 -0800 Created attachment 45894 fix build warnings 177170 24 45894 aroben 2010-01-05 08:42:49 -0800 Comment on attachment 45894 fix build warnings r=me 177171 25 darin 2010-01-05 08:43:58 -0800 It seems clear to me that we should change the type of the argument to SharedBuffer::append to unsigned. That will affect more files than this, but we don't want all these typecasts. I am very surprised you need that cast to int, though. 177172 26 yong.li.webkit 2010-01-05 08:46:31 -0800 (In reply to comment #25) > It seems clear to me that we should change the type of the argument to > SharedBuffer::append to unsigned. That will affect more files than this, but we > don't want all these typecasts. > > I am very surprised you need that cast to int, though. I was worried about having more warning by changing the type of the argument. but just realized that int->unsigned won't give warning. will do that way 177173 27 darin 2010-01-05 08:50:10 -0800 (In reply to comment #26) > I was worried about having more warning by changing the type of the argument. > but just realized that int->unsigned won't give warning. will do that way Yes, I understand that you are worried, but you should not be! We can’t program based on fear ;-) 177175 28 45895 yong.li.webkit 2010-01-05 09:00:47 -0800 Created attachment 45895 fix build warning by change append(char*, int) to append(char*, unsigned) 177176 29 webkit.review.bot 2010-01-05 09:04:03 -0800 style-queue ran check-webkit-style on attachment 45895 without any errors. 177189 30 45900 yong.li.webkit 2010-01-05 09:32:05 -0800 Created attachment 45900 fix build warnings fix warnings and also replace (A < B ? A : B) with std::min 177192 31 45900 aroben 2010-01-05 09:35:14 -0800 Comment on attachment 45900 fix build warnings > - unsigned bytesToCopy = static_cast<unsigned>(length) < segmentFreeSpace ? static_cast<unsigned>(length) : segmentFreeSpace; > + unsigned bytesToCopy = std::min(length, segmentFreeSpace); Our style is to put "using namespace std;" at the top of the file and then omit the "std::" qualifier. Other than that, this looks good. r=me if you fix that before committing. 177197 32 yong.li.webkit 2010-01-05 09:42:59 -0800 (In reply to comment #31) > (From update of attachment 45900 [details]) > > - unsigned bytesToCopy = static_cast<unsigned>(length) < segmentFreeSpace ? static_cast<unsigned>(length) : segmentFreeSpace; > > + unsigned bytesToCopy = std::min(length, segmentFreeSpace); > > Our style is to put "using namespace std;" at the top of the file and then omit > the "std::" qualifier. > > Other than that, this looks good. > > r=me if you fix that before committing. thanks. doing it now 177203 33 yong.li.webkit 2010-01-05 10:10:46 -0800 closed 177204 34 45900 yong.li.webkit 2010-01-05 10:11:15 -0800 Comment on attachment 45900 fix build warnings clear flags 45821 2010-01-04 12:56:36 -0800 2010-01-04 14:34:27 -0800 (1) Make SharedBuffer use segments internally 33178-1.patch text/plain 12333 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTNhMDI1ZS4uNzcwYjM4OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxMC0wMS0wNCAgWW9uZyBMaSAgPHlv bGlAcmltLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBMZXQgU2hhcmVkQnVmZmVyIHVzZSBhIGdyb3VwIG9mIG1lbW9yeSBzZWdtZW50cyBpbnRl cm5hbGx5LgorICAgICAgICBJdCB3aWxsIG1lcmdlIHRoZSBzZWdtZW50cyBpbnRvIGEgZmxhdCBj b25zZWN1dGl2ZSBidWZmZXIgb25seSB3aGVuCisgICAgICAgIG5lY2Vzc2FyeS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMzMTc4CisKKyAgICAgICAg KiBwbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6YWxsb2NhdGVT ZWdtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OmZyZWVTZWdtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJl ZEJ1ZmZlcjo6flNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6 OmFkb3B0VmVjdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6c2l6ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6 U2hhcmVkQnVmZmVyOjphcHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpj bGVhcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmNvcHkpOgorICAgICAgICAo V2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpidWZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVk QnVmZmVyOjpnZXRTb21lRGF0YSk6CisgICAgICAgICogcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmg6 CisgICAgICAgICogcGxhdGZvcm0vY2YvU2hhcmVkQnVmZmVyQ0YuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKToKKyAgICAgICAg KiBwbGF0Zm9ybS9oYWlrdS9TaGFyZWRCdWZmZXJIYWlrdS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSk6CisgICAgICAgICogcGxh dGZvcm0vcXQvU2hhcmVkQnVmZmVyUXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVm ZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgorICAgICAgICAqIHBsYXRmb3JtL3dpbi9T aGFyZWRCdWZmZXJXaW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVh dGVXaXRoQ29udGVudHNPZkZpbGUpOgorCiAyMDEwLTAxLTA0ICBEbWl0cnkgVGl0b3YgIDxkaW1p Y2hAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIE5vdCByZXZpZXdlZCwgcmV2ZXJ0IHI1Mjc0NSBh bmQgcjUyNzQ2IG9uIGJlaGFsZiBvZiBOaWtvbGFzIFppbW1lcm1hbm4sIGFzIGRpc2N1c3NlZCBv biBJUkMuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAgYi9X ZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggNGEwZDBmMy4uYmFhYjVmYyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5 cmlnaHQgKEMpIDIwMDYsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICog Q29weXJpZ2h0IChDKSBSZXNlYXJjaCBJbiBNb3Rpb24gTGltaXRlZCAyMDA5LTIwMTAuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTI4LDMw ICsyOSw1MCBAQAogCiAjaW5jbHVkZSAiUHVyZ2VhYmxlQnVmZmVyLmgiCiAKKyNkZWZpbmUgU0VH TUVOVF9TSVpFICAgICAgICAoMHgxMDAwKQorI2RlZmluZSBTRUdNRU5UX1BPU19NQVNLICAgICgw eDBGRkYpCisjZGVmaW5lIEdFVF9TRUdNRU5UKHBvc2l0aW9uKSAoKHBvc2l0aW9uKSAvIFNFR01F TlRfU0laRSkKKyNkZWZpbmUgR0VUX09GRl9JTl9TRUdNRU5UKGdsb2JhbFBvc2l0aW9uKSAoKGds b2JhbFBvc2l0aW9uKSAmIFNFR01FTlRfUE9TX01BU0spCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAorc3RhdGljIGlubGluZSBjaGFyKiBhbGxvY2F0ZVNlZ21lbnQoKQoreworICAgIHJldHVybiBz dGF0aWNfY2FzdDxjaGFyKj4oZmFzdE1hbGxvYyhTRUdNRU5UX1NJWkUpKTsKK30KKworc3RhdGlj IGlubGluZSB2b2lkIGZyZWVTZWdtZW50KGNoYXIqIHApCit7CisgICAgZmFzdEZyZWUocCk7Cit9 CisKIFNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKCkKKyAgICA6IG1fc2l6ZSgwKQogewogfQog CiBTaGFyZWRCdWZmZXI6OlNoYXJlZEJ1ZmZlcihjb25zdCBjaGFyKiBkYXRhLCBpbnQgc2l6ZSkK KyAgICA6IG1fc2l6ZSgwKQogewotICAgIG1fYnVmZmVyLmFwcGVuZChkYXRhLCBzaXplKTsKKyAg ICBhcHBlbmQoZGF0YSwgc2l6ZSk7CiB9CiAKIFNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKGNv bnN0IHVuc2lnbmVkIGNoYXIqIGRhdGEsIGludCBzaXplKQorICAgIDogbV9zaXplKDApCiB7Ci0g ICAgbV9idWZmZXIuYXBwZW5kKGRhdGEsIHNpemUpOworICAgIGFwcGVuZChyZWludGVycHJldF9j YXN0PGNvbnN0IGNoYXIqPihkYXRhKSwgc2l6ZSk7CiB9CiAgICAgCiBTaGFyZWRCdWZmZXI6On5T aGFyZWRCdWZmZXIoKQogeworICAgIGNsZWFyKCk7CiB9CiAKIFBhc3NSZWZQdHI8U2hhcmVkQnVm ZmVyPiBTaGFyZWRCdWZmZXI6OmFkb3B0VmVjdG9yKFZlY3RvcjxjaGFyPiYgdmVjdG9yKQogewog ICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGJ1ZmZlciA9IGNyZWF0ZSgpOwogICAgIGJ1ZmZlci0+ bV9idWZmZXIuc3dhcCh2ZWN0b3IpOworICAgIGJ1ZmZlci0+bV9zaXplID0gYnVmZmVyLT5tX2J1 ZmZlci5zaXplKCk7CiAgICAgcmV0dXJuIGJ1ZmZlci5yZWxlYXNlKCk7CiB9CiAKQEAgLTcxLDcg KzkyLDcgQEAgdW5zaWduZWQgU2hhcmVkQnVmZmVyOjpzaXplKCkgY29uc3QKICAgICBpZiAobV9w dXJnZWFibGVCdWZmZXIpCiAgICAgICAgIHJldHVybiBtX3B1cmdlYWJsZUJ1ZmZlci0+c2l6ZSgp OwogICAgIAotICAgIHJldHVybiBtX2J1ZmZlci5zaXplKCk7CisgICAgcmV0dXJuIG1fc2l6ZTsK IH0KIAogY29uc3QgY2hhciogU2hhcmVkQnVmZmVyOjpkYXRhKCkgY29uc3QKQEAgLTgyLDcgKzEw Myw3IEBAIGNvbnN0IGNoYXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiAgICAgaWYgKG1f cHVyZ2VhYmxlQnVmZmVyKQogICAgICAgICByZXR1cm4gbV9wdXJnZWFibGVCdWZmZXItPmRhdGEo KTsKICAgICAKLSAgICByZXR1cm4gbV9idWZmZXIuZGF0YSgpOworICAgIHJldHVybiBidWZmZXIo KS5kYXRhKCk7CiB9CiAKIHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgY2hhciogZGF0 YSwgaW50IGxlbikKQEAgLTkxLDIwICsxMTIsNjkgQEAgdm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVu ZChjb25zdCBjaGFyKiBkYXRhLCBpbnQgbGVuKQogCiAgICAgbWF5YmVUcmFuc2ZlclBsYXRmb3Jt RGF0YSgpOwogICAgIAotICAgIG1fYnVmZmVyLmFwcGVuZChkYXRhLCBsZW4pOworICAgIHVuc2ln bmVkIHBvc0luU2VnbWVudCA9IEdFVF9PRkZfSU5fU0VHTUVOVChtX3NpemUgLSBtX2J1ZmZlci5z aXplKCkpOworICAgIG1fc2l6ZSArPSBsZW47CisKKyAgICBpZiAobV9zaXplIDw9IFNFR01FTlRf U0laRSkgeworICAgICAgICAvLyBObyBuZWVkIHRvIHVzZSBzZWdtZW50cyBmb3Igc21hbGwgcmVz b3VyY2UgZGF0YQorICAgICAgICBtX2J1ZmZlci5hcHBlbmQoZGF0YSwgbGVuKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIGNoYXIqIHNlZ21lbnQ7CisgICAgaWYgKCFwb3NJblNlZ21l bnQpIHsKKyAgICAgICAgc2VnbWVudCA9IGFsbG9jYXRlU2VnbWVudCgpOworICAgICAgICBtX3Nl Z21lbnRzLmFwcGVuZChzZWdtZW50KTsKKyAgICB9IGVsc2UKKyAgICAgICAgc2VnbWVudCA9IG1f c2VnbWVudHMubGFzdCgpICsgcG9zSW5TZWdtZW50OworCisgICAgdW5zaWduZWQgc2VnbWVudEZy ZWVTcGFjZSA9IFNFR01FTlRfU0laRSAtIHBvc0luU2VnbWVudDsKKyAgICB1bnNpZ25lZCB0b0Nv cHkgPSBsZW4gPCBzZWdtZW50RnJlZVNwYWNlID8gbGVuIDogc2VnbWVudEZyZWVTcGFjZTsKKwor ICAgIGZvciAoOzspIHsKKyAgICAgICAgbWVtY3B5KHNlZ21lbnQsIGRhdGEsIHRvQ29weSk7Cisg ICAgICAgIGlmIChsZW4gPT0gdG9Db3B5KQorICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAg bGVuIC09IHRvQ29weTsKKyAgICAgICAgZGF0YSArPSB0b0NvcHk7CisgICAgICAgIHNlZ21lbnQg PSBhbGxvY2F0ZVNlZ21lbnQoKTsKKyAgICAgICAgbV9zZWdtZW50cy5hcHBlbmQoc2VnbWVudCk7 CisgICAgICAgIHRvQ29weSA9IGxlbiA8IFNFR01FTlRfU0laRSA/IGxlbiA6IFNFR01FTlRfU0la RTsKKyAgICB9CiB9CiAKIHZvaWQgU2hhcmVkQnVmZmVyOjpjbGVhcigpCiB7CiAgICAgY2xlYXJQ bGF0Zm9ybURhdGEoKTsKICAgICAKKyAgICBmb3IgKFZlY3RvcjxjaGFyKj46Oml0ZXJhdG9yIGkg PSBtX3NlZ21lbnRzLmJlZ2luKCk7IGkgIT0gbV9zZWdtZW50cy5lbmQoKTsgKytpKQorICAgICAg ICBmcmVlU2VnbWVudCgqaSk7CisKKyAgICBtX3NlZ21lbnRzLmNsZWFyKCk7CisgICAgbV9zaXpl ID0gMDsKKwogICAgIG1fYnVmZmVyLmNsZWFyKCk7CiAgICAgbV9wdXJnZWFibGVCdWZmZXIuY2xl YXIoKTsKIH0KIAogUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y29weSgp IGNvbnN0CiB7Ci0gICAgcmV0dXJuIFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKGRhdGEoKSwgc2l6ZSgp KTsKKyAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBjbG9uZShhZG9wdFJlZihuZXcgU2hhcmVkQnVm ZmVyKCkpKTsKKyAgICBpZiAobV9wdXJnZWFibGVCdWZmZXIgfHwgaGFzUGxhdGZvcm1EYXRhKCkp IHsKKyAgICAgICAgY2xvbmUtPmFwcGVuZChkYXRhKCksIHNpemUoKSk7CisgICAgICAgIHJldHVy biBjbG9uZTsKKyAgICB9CisKKyAgICBjbG9uZS0+bV9zaXplID0gbV9zaXplOworICAgIGNsb25l LT5tX2J1ZmZlci5hcHBlbmQobV9idWZmZXIuZGF0YSgpLCBtX2J1ZmZlci5zaXplKCkpOworICAg IGNsb25lLT5tX3NlZ21lbnRzLnJlc2VydmVDYXBhY2l0eShtX3NlZ21lbnRzLnNpemUoKSk7Cisg ICAgZm9yIChWZWN0b3I8Y2hhcio+Ojpjb25zdF9pdGVyYXRvciBpID0gbV9zZWdtZW50cy5iZWdp bigpOyBpICE9IG1fc2VnbWVudHMuZW5kKCk7ICsraSkgeworICAgICAgICBjaGFyKiBzZWdtZW50 ID0gYWxsb2NhdGVTZWdtZW50KCk7CisgICAgICAgIG1lbWNweShzZWdtZW50LCAqaSwgU0VHTUVO VF9TSVpFKTsKKyAgICAgICAgY2xvbmUtPm1fc2VnbWVudHMuYXBwZW5kKHNlZ21lbnQpOworICAg IH0KKyAgICByZXR1cm4gY2xvbmU7CiB9CiAKIFB1cmdlYWJsZUJ1ZmZlciogU2hhcmVkQnVmZmVy OjpyZWxlYXNlUHVyZ2VhYmxlQnVmZmVyKCkKQEAgLTExMyw2ICsxODMsNTQgQEAgUHVyZ2VhYmxl QnVmZmVyKiBTaGFyZWRCdWZmZXI6OnJlbGVhc2VQdXJnZWFibGVCdWZmZXIoKQogICAgIHJldHVy biBtX3B1cmdlYWJsZUJ1ZmZlci5yZWxlYXNlKCk7IAogfQogCitjb25zdCBWZWN0b3I8Y2hhcj4m IFNoYXJlZEJ1ZmZlcjo6YnVmZmVyKCkgY29uc3QKK3sKKyAgICB1bnNpZ25lZCBidWZmZXJTaXpl ID0gbV9idWZmZXIuc2l6ZSgpOworICAgIGlmIChtX3NpemUgPiBidWZmZXJTaXplKSB7CisgICAg ICAgIG1fYnVmZmVyLnJlc2l6ZShtX3NpemUpOworICAgICAgICBjaGFyKiBkZXN0ID0gbV9idWZm ZXIuZGF0YSgpICsgYnVmZmVyU2l6ZTsKKyAgICAgICAgdW5zaWduZWQgbGVmdCA9IG1fc2l6ZSAt IGJ1ZmZlclNpemU7CisgICAgICAgIGZvciAoVmVjdG9yPGNoYXIqPjo6Y29uc3RfaXRlcmF0b3Ig aSA9IG1fc2VnbWVudHMuYmVnaW4oKTsgaSAhPSBtX3NlZ21lbnRzLmVuZCgpOyArK2kpIHsKKyAg ICAgICAgICAgIHVuc2lnbmVkIHRvQ29weSA9IGxlZnQgPCBTRUdNRU5UX1NJWkUgPyBsZWZ0IDog U0VHTUVOVF9TSVpFOworICAgICAgICAgICAgbWVtY3B5KGRlc3QsICppLCB0b0NvcHkpOworICAg ICAgICAgICAgZGVzdCArPSB0b0NvcHk7CisgICAgICAgICAgICBsZWZ0IC09IHRvQ29weTsKKyAg ICAgICAgICAgIGZyZWVTZWdtZW50KCppKTsKKyAgICAgICAgfQorICAgICAgICBtX3NlZ21lbnRz LmNsZWFyKCk7CisgICAgfQorICAgIHJldHVybiBtX2J1ZmZlcjsKK30KKwordW5zaWduZWQgU2hh cmVkQnVmZmVyOjpnZXRTb21lRGF0YShjb25zdCBjaGFyKiogc29tZURhdGEsIHVuc2lnbmVkIHBv cykgY29uc3QKK3sKKyAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKCkgfHwgbV9wdXJnZWFibGVCdWZm ZXIpIHsKKyAgICAgICAgKnNvbWVEYXRhID0gZGF0YSgpOworICAgICAgICByZXR1cm4gc2l6ZSgp OworICAgIH0KKworICAgIGlmIChwb3MgPj0gbV9zaXplKSB7CisgICAgICAgICpzb21lRGF0YSA9 IDA7CisgICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIHVuc2lnbmVkIGNvbnNlY3V0aXZl U2l6ZSA9IG1fYnVmZmVyLnNpemUoKTsKKyAgICBpZiAocG9zIDwgY29uc2VjdXRpdmVTaXplKSB7 CisgICAgICAgICpzb21lRGF0YSA9IG1fYnVmZmVyLmRhdGEoKSArIHBvczsKKyAgICAgICAgcmV0 dXJuIGNvbnNlY3V0aXZlU2l6ZSAtIHBvczsKKyAgICB9CisgCisgICAgcG9zIC09IGNvbnNlY3V0 aXZlU2l6ZTsKKyAgICB1bnNpZ25lZCBzZWdtZW50ZWRTaXplID0gbV9zaXplIC0gY29uc2VjdXRp dmVTaXplOworICAgIHVuc2lnbmVkIHNlZ21lbnRzID0gbV9zZWdtZW50cy5zaXplKCk7CisgICAg dW5zaWduZWQgc2VnbWVudCA9IEdFVF9TRUdNRU5UKHBvcyk7CisgICAgQVNTRVJUKHNlZ21lbnQg PCBzZWdtZW50cyk7CisKKyAgICB1bnNpZ25lZCBwb3NJblNlZ21lbnQgPSBHRVRfT0ZGX0lOX1NF R01FTlQocG9zKTsKKyAgICAqc29tZURhdGEgPSBtX3NlZ21lbnRzW3NlZ21lbnRdICsgcG9zSW5T ZWdtZW50OworICAgIHJldHVybiBzZWdtZW50ID09IHNlZ21lbnRzIC0gMSA/IHNlZ21lbnRlZFNp emUgLSBwb3MgOiBTRUdNRU5UX1NJWkUgLSBwb3NJblNlZ21lbnQ7Cit9CisKICNpZiAhUExBVEZP Uk0oQ0YpCiAKIGlubGluZSB2b2lkIFNoYXJlZEJ1ZmZlcjo6Y2xlYXJQbGF0Zm9ybURhdGEoKQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaCBiL1dlYkNvcmUvcGxh dGZvcm0vU2hhcmVkQnVmZmVyLmgKaW5kZXggMzQwNGEwYy4uZDYxYmFjMSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL1No YXJlZEJ1ZmZlci5oCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwNiBB cHBsZSBDb21wdXRlciwgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIENvcHlyaWdodCAo QykgUmVzZWFyY2ggSW4gTW90aW9uIExpbWl0ZWQgMjAwOS0yMDEwLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dAogICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC03Myw5ICs3NCwxNiBAQCBw dWJsaWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiB3cmFwQ0ZEYXRhKENG RGF0YVJlZik7CiAjZW5kaWYKIAorICAgIC8vIENhbGxpbmcgdGhpcyBmdW5jdGlvbiB3aWxsIGZv cmNlIGludGVybmFsIHNlZ21lbnRlZCBidWZmZXJzCisgICAgLy8gdG8gYmUgbWVyZ2VkIGludG8g YSBmbGF0IGJ1ZmZlci4gVXNlIGdldFNvbWVEYXRhKCkgd2hlbmV2ZXIgcG9zc2libGUKKyAgICAv LyBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLgogICAgIGNvbnN0IGNoYXIqIGRhdGEoKSBjb25zdDsK ICAgICB1bnNpZ25lZCBzaXplKCkgY29uc3Q7Ci0gICAgY29uc3QgVmVjdG9yPGNoYXI+ICZidWZm ZXIoKSB7IHJldHVybiBtX2J1ZmZlcjsgfQorCisgICAgLy8gQ2FsbGluZyB0aGlzIGZ1bmN0aW9u IHdpbGwgZm9yY2UgaW50ZXJuYWwgc2VnbWVudGVkIGJ1ZmZlcnMKKyAgICAvLyB0byBiZSBtZXJn ZWQgaW50byBhIGZsYXQgYnVmZmVyLiBVc2UgZ2V0U29tZURhdGEoKSB3aGVuZXZlciBwb3NzaWJs ZQorICAgIC8vIGZvciBiZXR0ZXIgcGVyZm9ybWFuY2UuCisgICAgY29uc3QgVmVjdG9yPGNoYXI+ ICZidWZmZXIoKSBjb25zdDsKIAogICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0dXJuIHNp emUoKSA9PSAwOyB9CiAKQEAgLTkwLDE3ICs5OCwzNCBAQCBwdWJsaWM6CiAKICAgICAvLyBFbnN1 cmUgdGhpcyBidWZmZXIgaGFzIG5vIG90aGVyIGNsaWVudHMgYmVmb3JlIGNhbGxpbmcgdGhpcy4K ICAgICBQdXJnZWFibGVCdWZmZXIqIHJlbGVhc2VQdXJnZWFibGVCdWZmZXIoKTsKLSAgICAKKwor ICAgIC8vIFJldHVybiB0aGUgZmxhdCBkYXRhIHNpemUgYWZ0ZXIgInBvcyIuICIqZGF0YSIgd2ls bCBiZSB0aGUgYWRkcmVzcworICAgIC8vIFJldHVybiAwIHdoZW4gbm8gbW9yZSBkYXRhIGxlZnQu CisgICAgLy8gV2hlbiBleHRyYWN0aW5nIGFsbCBkYXRhIHdpdGggZ2V0U29tZURhdGEoKSwgdGhl IGNhbGxlciBzaG91bGQKKyAgICAvLyByZXBlYXQgY2FsbGluZyBpdCB1bnRpbCBpdCByZXR1cm5z IDAuCisgICAgLy8gVXNhZ2U6CisgICAgLy8gICAgICBjb25zdCBjaGFyKiBzZWdtZW50OworICAg IC8vICAgICAgdW5zaWduZWQgcG9zID0gMDsKKyAgICAvLyAgICAgIHdoaWxlICh1bnNpZ25lZCBs ZW5ndGggPSBzaGFyZWRCdWZmZXItPmdldFNvbWVEYXRhKCZzZWdtZW50LCBwb3MpKSB7CisgICAg Ly8gICAgICAgICAgLy8gVXNlIHRoZSBkYXRhLiBmb3IgZXhhbXBsZTogZGVjb2Rlci0+ZGVjb2Rl KHNlZ21lbnQsIGxlbmd0aCk7CisgICAgLy8gICAgICAgICAgcG9zICs9IGxlbmd0aDsKKyAgICAv LyAgICAgIH0KKyAgICB1bnNpZ25lZCBnZXRTb21lRGF0YShjb25zdCBjaGFyKiogZGF0YSwgdW5z aWduZWQgcG9zaXRpb24gPSAwKSBjb25zdDsKKwogcHJpdmF0ZToKICAgICBTaGFyZWRCdWZmZXIo KTsKICAgICBTaGFyZWRCdWZmZXIoY29uc3QgY2hhciosIGludCk7CiAgICAgU2hhcmVkQnVmZmVy KGNvbnN0IHVuc2lnbmVkIGNoYXIqLCBpbnQpOwogICAgIAorICAgIHVuc2lnbmVkIGdldFNlZ21l bnQodW5zaWduZWQgcG9zaXRpb24pIGNvbnN0OworICAgIHVuc2lnbmVkIGdldE9mZnNldEluU2Vn bWVudCh1bnNpZ25lZCBnbG9iYWxQb3NpdGlvbikgY29uc3Q7CiAgICAgdm9pZCBjbGVhclBsYXRm b3JtRGF0YSgpOwogICAgIHZvaWQgbWF5YmVUcmFuc2ZlclBsYXRmb3JtRGF0YSgpOwogICAgIGJv b2wgaGFzUGxhdGZvcm1EYXRhKCkgY29uc3Q7CiAgICAgCi0gICAgVmVjdG9yPGNoYXI+IG1fYnVm ZmVyOworICAgIHVuc2lnbmVkIG1fc2l6ZTsKKyAgICBtdXRhYmxlIFZlY3RvcjxjaGFyPiBtX2J1 ZmZlcjsKKyAgICBtdXRhYmxlIFZlY3RvcjxjaGFyKj4gbV9zZWdtZW50czsKICAgICBPd25QdHI8 UHVyZ2VhYmxlQnVmZmVyPiBtX3B1cmdlYWJsZUJ1ZmZlcjsKICNpZiBQTEFURk9STShDRikKICAg ICBTaGFyZWRCdWZmZXIoQ0ZEYXRhUmVmKTsKQEAgLTExMCw0ICsxMzUsNCBAQCBwcml2YXRlOgog ICAgIAogfQogCi0jZW5kaWYKKyNlbmRpZiAvLyBTaGFyZWRCdWZmZXJfaApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9jZi9TaGFyZWRCdWZmZXJDRi5jcHAgYi9XZWJDb3JlL3BsYXRmb3Jt L2NmL1NoYXJlZEJ1ZmZlckNGLmNwcAppbmRleCAyNmZjMDdmLi5jOTZiZmNjIDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL2NmL1NoYXJlZEJ1ZmZlckNGLmNwcAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL2NmL1NoYXJlZEJ1ZmZlckNGLmNwcApAQCAtNzYsOSArNzYsOSBAQCB2b2lkIFNoYXJl ZEJ1ZmZlcjo6bWF5YmVUcmFuc2ZlclBsYXRmb3JtRGF0YSgpCiAgICAgaWYgKCFtX2NmRGF0YSkK ICAgICAgICAgcmV0dXJuOwogICAgIAotICAgIEFTU0VSVChtX2J1ZmZlci5zaXplKCkgPT0gMCk7 CisgICAgQVNTRVJUKG1fc2l6ZSA9PSAwKTsKICAgICAgICAgCi0gICAgbV9idWZmZXIuYXBwZW5k KChjb25zdCBjaGFyKilDRkRhdGFHZXRCeXRlUHRyKG1fY2ZEYXRhLmdldCgpKSwgQ0ZEYXRhR2V0 TGVuZ3RoKG1fY2ZEYXRhLmdldCgpKSk7CisgICAgYXBwZW5kKChjb25zdCBjaGFyKilDRkRhdGFH ZXRCeXRlUHRyKG1fY2ZEYXRhLmdldCgpKSwgQ0ZEYXRhR2V0TGVuZ3RoKG1fY2ZEYXRhLmdldCgp KSk7CiAgICAgICAgIAogICAgIG1fY2ZEYXRhID0gMDsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vaGFpa3UvU2hhcmVkQnVmZmVySGFpa3UuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9o YWlrdS9TaGFyZWRCdWZmZXJIYWlrdS5jcHAKaW5kZXggMTEzY2QyZS4uYWJlOWUyZCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9oYWlrdS9TaGFyZWRCdWZmZXJIYWlrdS5jcHAKKysrIGIv V2ViQ29yZS9wbGF0Zm9ybS9oYWlrdS9TaGFyZWRCdWZmZXJIYWlrdS5jcHAKQEAgLTQ3LDYgKzQ3 LDcgQEAgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENv bnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmkKICAgICByZXN1bHQtPm1fYnVmZmVyLnJlc2l6 ZShzaXplKTsKICAgICBpZiAocmVzdWx0LT5tX2J1ZmZlci5zaXplKCkgIT0gc2l6ZSkKICAgICAg ICAgcmV0dXJuIDA7CisgICAgcmVzdWx0LT5tX3NpemUgPSBzaXplOwogCiAgICAgZmlsZS5SZWFk KHJlc3VsdC0+bV9idWZmZXIuZGF0YSgpLCByZXN1bHQtPm1fYnVmZmVyLnNpemUoKSk7CiAgICAg cmV0dXJuIHJlc3VsdC5yZWxlYXNlKCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL3F0 L1NoYXJlZEJ1ZmZlclF0LmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vcXQvU2hhcmVkQnVmZmVyUXQu Y3BwCmluZGV4IDhkNjIyMjYuLjAyOWQ5ZDYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v cXQvU2hhcmVkQnVmZmVyUXQuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vcXQvU2hhcmVkQnVm ZmVyUXQuY3BwCkBAIC00NSw2ICs0NSw4IEBAIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFy ZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZShjb25zdCBTdHJpbmcmIGZpCiAgICAg aWYgKHJlc3VsdC0+bV9idWZmZXIuc2l6ZSgpICE9IGZpbGUuc2l6ZSgpKQogICAgICAgICByZXR1 cm4gMDsKIAorICAgIHJlc3VsdC0+bV9zaXplID0gcmVzdWx0LT5tX2J1ZmZlci5zaXplKCk7CisK ICAgICBmaWxlLnJlYWQocmVzdWx0LT5tX2J1ZmZlci5kYXRhKCksIHJlc3VsdC0+bV9idWZmZXIu c2l6ZSgpKTsKICAgICByZXR1cm4gcmVzdWx0LnJlbGVhc2UoKTsKIH0KZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAgYi9XZWJDb3JlL3BsYXRmb3Jt L3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCmluZGV4IDE4MzljOTkuLmE5NWQ1OTAgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGxhdGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKKysrIGIvV2ViQ29y ZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcApAQCAtNTcsNiArNTcsOCBAQCBQYXNz UmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZp bGUoY29uc3QgU3RyaW5nJiBmaQogICAgICAgICBnb3RvIGV4aXQ7CiAgICAgfQogCisgICAgcmVz dWx0LT5tX3NpemUgPSByZXN1bHQtPm1fYnVmZmVyLnNpemUoKTsKKwogICAgIGlmIChmcmVhZChy ZXN1bHQtPm1fYnVmZmVyLmRhdGEoKSwgMSwgZmlsZVN0YXQuc3Rfc2l6ZSwgZmlsZURlc2NyaXB0 b3IpICE9IGZpbGVTdGF0LnN0X3NpemUpCiAgICAgICAgIExPR19FUlJPUigiRmFpbGVkIHRvIGZ1 bGx5IHJlYWQgY29udGVudHMgb2YgZmlsZSAlcyAtIGVycm5vKCVpKSIsIGZpbGVQYXRoLmFzY2lp KCkuZGF0YSgpLCBlcnJubyk7CiAK 45830 2010-01-04 14:34:27 -0800 2010-01-05 07:26:34 -0800 (1) make SharedBuffer use segments internally 33178-1.patch text/plain 12338 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTNhMDI1ZS4uNzcwYjM4OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxMC0wMS0wNCAgWW9uZyBMaSAgPHlv bGlAcmltLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBMZXQgU2hhcmVkQnVmZmVyIHVzZSBhIGdyb3VwIG9mIG1lbW9yeSBzZWdtZW50cyBpbnRl cm5hbGx5LgorICAgICAgICBJdCB3aWxsIG1lcmdlIHRoZSBzZWdtZW50cyBpbnRvIGEgZmxhdCBj b25zZWN1dGl2ZSBidWZmZXIgb25seSB3aGVuCisgICAgICAgIG5lY2Vzc2FyeS4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMzMTc4CisKKyAgICAgICAg KiBwbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6YWxsb2NhdGVT ZWdtZW50KToKKyAgICAgICAgKFdlYkNvcmU6OmZyZWVTZWdtZW50KToKKyAgICAgICAgKFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJl ZEJ1ZmZlcjo6flNoYXJlZEJ1ZmZlcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6 OmFkb3B0VmVjdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6c2l6ZSk6Cisg ICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmRhdGEpOgorICAgICAgICAoV2ViQ29yZTo6 U2hhcmVkQnVmZmVyOjphcHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpj bGVhcik6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6OmNvcHkpOgorICAgICAgICAo V2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpidWZmZXIpOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVk QnVmZmVyOjpnZXRTb21lRGF0YSk6CisgICAgICAgICogcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmg6 CisgICAgICAgICogcGxhdGZvcm0vY2YvU2hhcmVkQnVmZmVyQ0YuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKToKKyAgICAgICAg KiBwbGF0Zm9ybS9oYWlrdS9TaGFyZWRCdWZmZXJIYWlrdS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50c09mRmlsZSk6CisgICAgICAgICogcGxh dGZvcm0vcXQvU2hhcmVkQnVmZmVyUXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVm ZmVyOjpjcmVhdGVXaXRoQ29udGVudHNPZkZpbGUpOgorICAgICAgICAqIHBsYXRmb3JtL3dpbi9T aGFyZWRCdWZmZXJXaW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVh dGVXaXRoQ29udGVudHNPZkZpbGUpOgorCiAyMDEwLTAxLTA0ICBEbWl0cnkgVGl0b3YgIDxkaW1p Y2hAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIE5vdCByZXZpZXdlZCwgcmV2ZXJ0IHI1Mjc0NSBh bmQgcjUyNzQ2IG9uIGJlaGFsZiBvZiBOaWtvbGFzIFppbW1lcm1hbm4sIGFzIGRpc2N1c3NlZCBv biBJUkMuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAgYi9X ZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggNGEwZDBmMy4uYWFlYTdiMyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5 cmlnaHQgKEMpIDIwMDYsIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICog Q29weXJpZ2h0IChDKSBSZXNlYXJjaCBJbiBNb3Rpb24gTGltaXRlZCAyMDA5LTIwMTAuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCiAgKgogICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKQEAgLTMwLDI4 ICszMSw1NiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBjb25zdCB1bnNpZ25l ZCBzZWdtZW50U2l6ZSA9IDB4MTAwMDsKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBzZWdtZW50UG9z aXRpb25NYXNrID0gMHgwRkZGOworCitzdGF0aWMgdW5zaWduZWQgc2VnbWVudEluZGV4KHVuc2ln bmVkIHBvc2l0aW9uKQoreworICAgIHJldHVybiBwb3NpdGlvbiAvIHNlZ21lbnRTaXplOworfQor CitzdGF0aWMgdW5zaWduZWQgb2Zmc2V0SW5TZWdtZW50KHVuc2lnbmVkIHBvc2l0aW9uKQorewor ICAgIHJldHVybiBwb3NpdGlvbiAmIHNlZ21lbnRQb3NpdGlvbk1hc2s7Cit9CisKK3N0YXRpYyBp bmxpbmUgY2hhciogYWxsb2NhdGVTZWdtZW50KCkKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8 Y2hhcio+KGZhc3RNYWxsb2Moc2VnbWVudFNpemUpKTsKK30KKworc3RhdGljIGlubGluZSB2b2lk IGZyZWVTZWdtZW50KGNoYXIqIHApCit7CisgICAgZmFzdEZyZWUocCk7Cit9CisKIFNoYXJlZEJ1 ZmZlcjo6U2hhcmVkQnVmZmVyKCkKKyAgICA6IG1fc2l6ZSgwKQogewogfQogCiBTaGFyZWRCdWZm ZXI6OlNoYXJlZEJ1ZmZlcihjb25zdCBjaGFyKiBkYXRhLCBpbnQgc2l6ZSkKKyAgICA6IG1fc2l6 ZSgwKQogewotICAgIG1fYnVmZmVyLmFwcGVuZChkYXRhLCBzaXplKTsKKyAgICBhcHBlbmQoZGF0 YSwgc2l6ZSk7CiB9CiAKIFNoYXJlZEJ1ZmZlcjo6U2hhcmVkQnVmZmVyKGNvbnN0IHVuc2lnbmVk IGNoYXIqIGRhdGEsIGludCBzaXplKQorICAgIDogbV9zaXplKDApCiB7Ci0gICAgbV9idWZmZXIu YXBwZW5kKGRhdGEsIHNpemUpOworICAgIGFwcGVuZChyZWludGVycHJldF9jYXN0PGNvbnN0IGNo YXIqPihkYXRhKSwgc2l6ZSk7CiB9CiAgICAgCiBTaGFyZWRCdWZmZXI6On5TaGFyZWRCdWZmZXIo KQogeworICAgIGNsZWFyKCk7CiB9CiAKIFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRC dWZmZXI6OmFkb3B0VmVjdG9yKFZlY3RvcjxjaGFyPiYgdmVjdG9yKQogewogICAgIFJlZlB0cjxT aGFyZWRCdWZmZXI+IGJ1ZmZlciA9IGNyZWF0ZSgpOwogICAgIGJ1ZmZlci0+bV9idWZmZXIuc3dh cCh2ZWN0b3IpOworICAgIGJ1ZmZlci0+bV9zaXplID0gYnVmZmVyLT5tX2J1ZmZlci5zaXplKCk7 CiAgICAgcmV0dXJuIGJ1ZmZlci5yZWxlYXNlKCk7CiB9CiAKQEAgLTcxLDcgKzEwMCw3IEBAIHVu c2lnbmVkIFNoYXJlZEJ1ZmZlcjo6c2l6ZSgpIGNvbnN0CiAgICAgaWYgKG1fcHVyZ2VhYmxlQnVm ZmVyKQogICAgICAgICByZXR1cm4gbV9wdXJnZWFibGVCdWZmZXItPnNpemUoKTsKICAgICAKLSAg ICByZXR1cm4gbV9idWZmZXIuc2l6ZSgpOworICAgIHJldHVybiBtX3NpemU7CiB9CiAKIGNvbnN0 IGNoYXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CkBAIC04MiwyOSArMTExLDc1IEBAIGNv bnN0IGNoYXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiAgICAgaWYgKG1fcHVyZ2VhYmxl QnVmZmVyKQogICAgICAgICByZXR1cm4gbV9wdXJnZWFibGVCdWZmZXItPmRhdGEoKTsKICAgICAK LSAgICByZXR1cm4gbV9idWZmZXIuZGF0YSgpOworICAgIHJldHVybiBidWZmZXIoKS5kYXRhKCk7 CiB9CiAKLXZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgY2hhciogZGF0YSwgaW50IGxl bikKK3ZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgY2hhciogZGF0YSwgaW50IGxlbmd0 aCkKIHsKICAgICBBU1NFUlQoIW1fcHVyZ2VhYmxlQnVmZmVyKTsKIAogICAgIG1heWJlVHJhbnNm ZXJQbGF0Zm9ybURhdGEoKTsKICAgICAKLSAgICBtX2J1ZmZlci5hcHBlbmQoZGF0YSwgbGVuKTsK KyAgICB1bnNpZ25lZCBwb3NpdGlvbkluU2VnbWVudCA9IG9mZnNldEluU2VnbWVudChtX3NpemUg LSBtX2J1ZmZlci5zaXplKCkpOworICAgIG1fc2l6ZSArPSBsZW5ndGg7CisKKyAgICBpZiAobV9z aXplIDw9IHNlZ21lbnRTaXplKSB7CisgICAgICAgIC8vIE5vIG5lZWQgdG8gdXNlIHNlZ21lbnRz IGZvciBzbWFsbCByZXNvdXJjZSBkYXRhCisgICAgICAgIG1fYnVmZmVyLmFwcGVuZChkYXRhLCBs ZW5ndGgpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgY2hhciogc2VnbWVudDsKKyAg ICBpZiAoIXBvc2l0aW9uSW5TZWdtZW50KSB7CisgICAgICAgIHNlZ21lbnQgPSBhbGxvY2F0ZVNl Z21lbnQoKTsKKyAgICAgICAgbV9zZWdtZW50cy5hcHBlbmQoc2VnbWVudCk7CisgICAgfSBlbHNl CisgICAgICAgIHNlZ21lbnQgPSBtX3NlZ21lbnRzLmxhc3QoKSArIHBvc2l0aW9uSW5TZWdtZW50 OworCisgICAgdW5zaWduZWQgc2VnbWVudEZyZWVTcGFjZSA9IHNlZ21lbnRTaXplIC0gcG9zaXRp b25JblNlZ21lbnQ7CisgICAgdW5zaWduZWQgYnl0ZXNUb0NvcHkgPSBsZW5ndGggPCBzZWdtZW50 RnJlZVNwYWNlID8gbGVuZ3RoIDogc2VnbWVudEZyZWVTcGFjZTsKKworICAgIGZvciAoOzspIHsK KyAgICAgICAgbWVtY3B5KHNlZ21lbnQsIGRhdGEsIGJ5dGVzVG9Db3B5KTsKKyAgICAgICAgaWYg KGxlbmd0aCA9PSBieXRlc1RvQ29weSkKKyAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgIGxl bmd0aCAtPSBieXRlc1RvQ29weTsKKyAgICAgICAgZGF0YSArPSBieXRlc1RvQ29weTsKKyAgICAg ICAgc2VnbWVudCA9IGFsbG9jYXRlU2VnbWVudCgpOworICAgICAgICBtX3NlZ21lbnRzLmFwcGVu ZChzZWdtZW50KTsKKyAgICAgICAgYnl0ZXNUb0NvcHkgPSBsZW5ndGggPCBzZWdtZW50U2l6ZSA/ IGxlbmd0aCA6IHNlZ21lbnRTaXplOworICAgIH0KIH0KIAogdm9pZCBTaGFyZWRCdWZmZXI6OmNs ZWFyKCkKIHsKICAgICBjbGVhclBsYXRmb3JtRGF0YSgpOwogICAgIAorICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBtX3NlZ21lbnRzLnNpemUoKTsgKytpKQorICAgICAgICBmcmVlU2VnbWVu dChtX3NlZ21lbnRzW2ldKTsKKworICAgIG1fc2VnbWVudHMuY2xlYXIoKTsKKyAgICBtX3NpemUg PSAwOworCiAgICAgbV9idWZmZXIuY2xlYXIoKTsKICAgICBtX3B1cmdlYWJsZUJ1ZmZlci5jbGVh cigpOwogfQogCiBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjb3B5KCkg Y29uc3QKIHsKLSAgICByZXR1cm4gU2hhcmVkQnVmZmVyOjpjcmVhdGUoZGF0YSgpLCBzaXplKCkp OworICAgIFJlZlB0cjxTaGFyZWRCdWZmZXI+IGNsb25lKGFkb3B0UmVmKG5ldyBTaGFyZWRCdWZm ZXIpKTsKKyAgICBpZiAobV9wdXJnZWFibGVCdWZmZXIgfHwgaGFzUGxhdGZvcm1EYXRhKCkpIHsK KyAgICAgICAgY2xvbmUtPmFwcGVuZChkYXRhKCksIHNpemUoKSk7CisgICAgICAgIHJldHVybiBj bG9uZTsKKyAgICB9CisKKyAgICBjbG9uZS0+bV9zaXplID0gbV9zaXplOworICAgIGNsb25lLT5t X2J1ZmZlci5yZXNlcnZlQ2FwYWNpdHkobV9zaXplKTsKKyAgICBjbG9uZS0+bV9idWZmZXIuYXBw ZW5kKG1fYnVmZmVyLmRhdGEoKSwgbV9idWZmZXIuc2l6ZSgpKTsKKyAgICBmb3IgKHVuc2lnbmVk IGkgPSAwOyBpIDwgbV9zZWdtZW50cy5zaXplKCk7ICsraSkKKyAgICAgICAgY2xvbmUtPm1fYnVm ZmVyLmFwcGVuZChtX3NlZ21lbnRzW2ldLCBzZWdtZW50U2l6ZSk7CisgICAgcmV0dXJuIGNsb25l OwogfQogCiBQdXJnZWFibGVCdWZmZXIqIFNoYXJlZEJ1ZmZlcjo6cmVsZWFzZVB1cmdlYWJsZUJ1 ZmZlcigpCkBAIC0xMTMsNiArMTg4LDU0IEBAIFB1cmdlYWJsZUJ1ZmZlciogU2hhcmVkQnVmZmVy OjpyZWxlYXNlUHVyZ2VhYmxlQnVmZmVyKCkKICAgICByZXR1cm4gbV9wdXJnZWFibGVCdWZmZXIu cmVsZWFzZSgpOyAKIH0KIAorY29uc3QgVmVjdG9yPGNoYXI+JiBTaGFyZWRCdWZmZXI6OmJ1ZmZl cigpIGNvbnN0Cit7CisgICAgdW5zaWduZWQgYnVmZmVyU2l6ZSA9IG1fYnVmZmVyLnNpemUoKTsK KyAgICBpZiAobV9zaXplID4gYnVmZmVyU2l6ZSkgeworICAgICAgICBtX2J1ZmZlci5yZXNpemUo bV9zaXplKTsKKyAgICAgICAgY2hhciogZGVzdGluYXRpb24gPSBtX2J1ZmZlci5kYXRhKCkgKyBi dWZmZXJTaXplOworICAgICAgICB1bnNpZ25lZCBieXRlc0xlZnQgPSBtX3NpemUgLSBidWZmZXJT aXplOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbV9zZWdtZW50cy5zaXplKCk7 ICsraSkgeworICAgICAgICAgICAgdW5zaWduZWQgYnl0ZXNUb0NvcHkgPSBieXRlc0xlZnQgPCBz ZWdtZW50U2l6ZSA/IGJ5dGVzTGVmdCA6IHNlZ21lbnRTaXplOworICAgICAgICAgICAgbWVtY3B5 KGRlc3RpbmF0aW9uLCBtX3NlZ21lbnRzW2ldLCBieXRlc1RvQ29weSk7CisgICAgICAgICAgICBk ZXN0aW5hdGlvbiArPSBieXRlc1RvQ29weTsKKyAgICAgICAgICAgIGJ5dGVzTGVmdCAtPSBieXRl c1RvQ29weTsKKyAgICAgICAgICAgIGZyZWVTZWdtZW50KG1fc2VnbWVudHNbaV0pOworICAgICAg ICB9CisgICAgICAgIG1fc2VnbWVudHMuY2xlYXIoKTsKKyAgICB9CisgICAgcmV0dXJuIG1fYnVm ZmVyOworfQorCit1bnNpZ25lZCBTaGFyZWRCdWZmZXI6OmdldFNvbWVEYXRhKGNvbnN0IGNoYXIq JiBzb21lRGF0YSwgdW5zaWduZWQgcG9zKSBjb25zdAoreworICAgIGlmIChoYXNQbGF0Zm9ybURh dGEoKSB8fCBtX3B1cmdlYWJsZUJ1ZmZlcikgeworICAgICAgICBzb21lRGF0YSA9IGRhdGEoKSAr IHBvczsKKyAgICAgICAgcmV0dXJuIHNpemUoKSAtIHBvczsKKyAgICB9CisKKyAgICBpZiAocG9z ID49IG1fc2l6ZSkgeworICAgICAgICBzb21lRGF0YSA9IDA7CisgICAgICAgIHJldHVybiAwOwor ICAgIH0KKworICAgIHVuc2lnbmVkIGNvbnNlY3V0aXZlU2l6ZSA9IG1fYnVmZmVyLnNpemUoKTsK KyAgICBpZiAocG9zIDwgY29uc2VjdXRpdmVTaXplKSB7CisgICAgICAgIHNvbWVEYXRhID0gbV9i dWZmZXIuZGF0YSgpICsgcG9zOworICAgICAgICByZXR1cm4gY29uc2VjdXRpdmVTaXplIC0gcG9z OworICAgIH0KKyAKKyAgICBwb3MgLT0gY29uc2VjdXRpdmVTaXplOworICAgIHVuc2lnbmVkIHNl Z21lbnRlZFNpemUgPSBtX3NpemUgLSBjb25zZWN1dGl2ZVNpemU7CisgICAgdW5zaWduZWQgc2Vn bWVudHMgPSBtX3NlZ21lbnRzLnNpemUoKTsKKyAgICB1bnNpZ25lZCBzZWdtZW50ID0gc2VnbWVu dEluZGV4KHBvcyk7CisgICAgQVNTRVJUKHNlZ21lbnQgPCBzZWdtZW50cyk7CisKKyAgICB1bnNp Z25lZCBwb3NpdGlvbkluU2VnbWVudCA9IG9mZnNldEluU2VnbWVudChwb3MpOworICAgIHNvbWVE YXRhID0gbV9zZWdtZW50c1tzZWdtZW50XSArIHBvc2l0aW9uSW5TZWdtZW50OworICAgIHJldHVy biBzZWdtZW50ID09IHNlZ21lbnRzIC0gMSA/IHNlZ21lbnRlZFNpemUgLSBwb3MgOiBzZWdtZW50 U2l6ZSAtIHBvc2l0aW9uSW5TZWdtZW50OworfQorCiAjaWYgIVBMQVRGT1JNKENGKQogCiBpbmxp bmUgdm9pZCBTaGFyZWRCdWZmZXI6OmNsZWFyUGxhdGZvcm1EYXRhKCkKZGlmZiAtLWdpdCBhL1dl YkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmggYi9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1 ZmZlci5oCmluZGV4IDM0MDRhMGMuLjc1MGE1OWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZv cm0vU2hhcmVkQnVmZmVyLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaApA QCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIs IEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIFJlc2VhcmNoIElu IE1vdGlvbiBMaW1pdGVkIDIwMDktMjAxMC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtNzMsMTEgKzc0LDE5IEBAIHB1YmxpYzoKICAgICBz dGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+IHdyYXBDRkRhdGEoQ0ZEYXRhUmVmKTsKICNl bmRpZgogCisgICAgLy8gQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpbGwgZm9yY2UgaW50ZXJuYWwg c2VnbWVudGVkIGJ1ZmZlcnMKKyAgICAvLyB0byBiZSBtZXJnZWQgaW50byBhIGZsYXQgYnVmZmVy LiBVc2UgZ2V0U29tZURhdGEoKSB3aGVuZXZlciBwb3NzaWJsZQorICAgIC8vIGZvciBiZXR0ZXIg cGVyZm9ybWFuY2UuCiAgICAgY29uc3QgY2hhciogZGF0YSgpIGNvbnN0OworCiAgICAgdW5zaWdu ZWQgc2l6ZSgpIGNvbnN0OwotICAgIGNvbnN0IFZlY3RvcjxjaGFyPiAmYnVmZmVyKCkgeyByZXR1 cm4gbV9idWZmZXI7IH0KIAotICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0dXJuIHNpemUo KSA9PSAwOyB9CisgICAgLy8gQ2FsbGluZyB0aGlzIGZ1bmN0aW9uIHdpbGwgZm9yY2UgaW50ZXJu YWwgc2VnbWVudGVkIGJ1ZmZlcnMKKyAgICAvLyB0byBiZSBtZXJnZWQgaW50byBhIGZsYXQgYnVm ZmVyLiBVc2UgZ2V0U29tZURhdGEoKSB3aGVuZXZlciBwb3NzaWJsZQorICAgIC8vIGZvciBiZXR0 ZXIgcGVyZm9ybWFuY2UuCisgICAgY29uc3QgVmVjdG9yPGNoYXI+JiBidWZmZXIoKSBjb25zdDsK KworICAgIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0dXJuIHNpemUoKTsgfQogCiAgICAgdm9p ZCBhcHBlbmQoY29uc3QgY2hhciosIGludCk7CiAgICAgdm9pZCBjbGVhcigpOwpAQCAtOTAsNyAr OTksMjEgQEAgcHVibGljOgogCiAgICAgLy8gRW5zdXJlIHRoaXMgYnVmZmVyIGhhcyBubyBvdGhl ciBjbGllbnRzIGJlZm9yZSBjYWxsaW5nIHRoaXMuCiAgICAgUHVyZ2VhYmxlQnVmZmVyKiByZWxl YXNlUHVyZ2VhYmxlQnVmZmVyKCk7Ci0gICAgCisKKyAgICAvLyBSZXR1cm4gdGhlIG51bWJlciBv ZiBjb25zZWN1dGl2ZSBieXRlcyBhZnRlciAicG9zaXRpb24iLiAiZGF0YSIKKyAgICAvLyBwb2lu dHMgdG8gdGhlIGZpcnN0IGJ5dGUuCisgICAgLy8gUmV0dXJuIDAgd2hlbiBubyBtb3JlIGRhdGEg bGVmdC4KKyAgICAvLyBXaGVuIGV4dHJhY3RpbmcgYWxsIGRhdGEgd2l0aCBnZXRTb21lRGF0YSgp LCB0aGUgY2FsbGVyIHNob3VsZAorICAgIC8vIHJlcGVhdCBjYWxsaW5nIGl0IHVudGlsIGl0IHJl dHVybnMgMC4KKyAgICAvLyBVc2FnZToKKyAgICAvLyAgICAgIGNvbnN0IGNoYXIqIHNlZ21lbnQ7 CisgICAgLy8gICAgICB1bnNpZ25lZCBwb3MgPSAwOworICAgIC8vICAgICAgd2hpbGUgKHVuc2ln bmVkIGxlbmd0aCA9IHNoYXJlZEJ1ZmZlci0+Z2V0U29tZURhdGEoc2VnbWVudCwgcG9zKSkgewor ICAgIC8vICAgICAgICAgIC8vIFVzZSB0aGUgZGF0YS4gZm9yIGV4YW1wbGU6IGRlY29kZXItPmRl Y29kZShzZWdtZW50LCBsZW5ndGgpOworICAgIC8vICAgICAgICAgIHBvcyArPSBsZW5ndGg7Cisg ICAgLy8gICAgICB9CisgICAgdW5zaWduZWQgZ2V0U29tZURhdGEoY29uc3QgY2hhciomIGRhdGEs IHVuc2lnbmVkIHBvc2l0aW9uID0gMCkgY29uc3Q7CisKIHByaXZhdGU6CiAgICAgU2hhcmVkQnVm ZmVyKCk7CiAgICAgU2hhcmVkQnVmZmVyKGNvbnN0IGNoYXIqLCBpbnQpOwpAQCAtMTAwLDcgKzEy Myw5IEBAIHByaXZhdGU6CiAgICAgdm9pZCBtYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKCk7CiAg ICAgYm9vbCBoYXNQbGF0Zm9ybURhdGEoKSBjb25zdDsKICAgICAKLSAgICBWZWN0b3I8Y2hhcj4g bV9idWZmZXI7CisgICAgdW5zaWduZWQgbV9zaXplOworICAgIG11dGFibGUgVmVjdG9yPGNoYXI+ IG1fYnVmZmVyOworICAgIG11dGFibGUgVmVjdG9yPGNoYXIqPiBtX3NlZ21lbnRzOwogICAgIE93 blB0cjxQdXJnZWFibGVCdWZmZXI+IG1fcHVyZ2VhYmxlQnVmZmVyOwogI2lmIFBMQVRGT1JNKENG KQogICAgIFNoYXJlZEJ1ZmZlcihDRkRhdGFSZWYpOwpAQCAtMTEwLDQgKzEzNSw0IEBAIHByaXZh dGU6CiAgICAgCiB9CiAKLSNlbmRpZgorI2VuZGlmIC8vIFNoYXJlZEJ1ZmZlcl9oCmRpZmYgLS1n aXQgYS9XZWJDb3JlL3BsYXRmb3JtL2NmL1NoYXJlZEJ1ZmZlckNGLmNwcCBiL1dlYkNvcmUvcGxh dGZvcm0vY2YvU2hhcmVkQnVmZmVyQ0YuY3BwCmluZGV4IDI2ZmMwN2YuLmM5NmJmY2MgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vY2YvU2hhcmVkQnVmZmVyQ0YuY3BwCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vY2YvU2hhcmVkQnVmZmVyQ0YuY3BwCkBAIC03Niw5ICs3Niw5IEBAIHZvaWQg U2hhcmVkQnVmZmVyOjptYXliZVRyYW5zZmVyUGxhdGZvcm1EYXRhKCkKICAgICBpZiAoIW1fY2ZE YXRhKQogICAgICAgICByZXR1cm47CiAgICAgCi0gICAgQVNTRVJUKG1fYnVmZmVyLnNpemUoKSA9 PSAwKTsKKyAgICBBU1NFUlQobV9zaXplID09IDApOwogICAgICAgICAKLSAgICBtX2J1ZmZlci5h cHBlbmQoKGNvbnN0IGNoYXIqKUNGRGF0YUdldEJ5dGVQdHIobV9jZkRhdGEuZ2V0KCkpLCBDRkRh dGFHZXRMZW5ndGgobV9jZkRhdGEuZ2V0KCkpKTsKKyAgICBhcHBlbmQoKGNvbnN0IGNoYXIqKUNG RGF0YUdldEJ5dGVQdHIobV9jZkRhdGEuZ2V0KCkpLCBDRkRhdGFHZXRMZW5ndGgobV9jZkRhdGEu Z2V0KCkpKTsKICAgICAgICAgCiAgICAgbV9jZkRhdGEgPSAwOwogfQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wbGF0Zm9ybS9oYWlrdS9TaGFyZWRCdWZmZXJIYWlrdS5jcHAgYi9XZWJDb3JlL3BsYXRm b3JtL2hhaWt1L1NoYXJlZEJ1ZmZlckhhaWt1LmNwcAppbmRleCAxMTNjZDJlLi5hYmU5ZTJkIDEw MDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2hhaWt1L1NoYXJlZEJ1ZmZlckhhaWt1LmNwcAor KysgYi9XZWJDb3JlL3BsYXRmb3JtL2hhaWt1L1NoYXJlZEJ1ZmZlckhhaWt1LmNwcApAQCAtNDcs NiArNDcsNyBAQCBQYXNzUmVmUHRyPFNoYXJlZEJ1ZmZlcj4gU2hhcmVkQnVmZmVyOjpjcmVhdGVX aXRoQ29udGVudHNPZkZpbGUoY29uc3QgU3RyaW5nJiBmaQogICAgIHJlc3VsdC0+bV9idWZmZXIu cmVzaXplKHNpemUpOwogICAgIGlmIChyZXN1bHQtPm1fYnVmZmVyLnNpemUoKSAhPSBzaXplKQog ICAgICAgICByZXR1cm4gMDsKKyAgICByZXN1bHQtPm1fc2l6ZSA9IHNpemU7CiAKICAgICBmaWxl LlJlYWQocmVzdWx0LT5tX2J1ZmZlci5kYXRhKCksIHJlc3VsdC0+bV9idWZmZXIuc2l6ZSgpKTsK ICAgICByZXR1cm4gcmVzdWx0LnJlbGVhc2UoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZv cm0vcXQvU2hhcmVkQnVmZmVyUXQuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9xdC9TaGFyZWRCdWZm ZXJRdC5jcHAKaW5kZXggOGQ2MjIyNi4uMDI5ZDlkNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0 Zm9ybS9xdC9TaGFyZWRCdWZmZXJRdC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9xdC9TaGFy ZWRCdWZmZXJRdC5jcHAKQEAgLTQ1LDYgKzQ1LDggQEAgUGFzc1JlZlB0cjxTaGFyZWRCdWZmZXI+ IFNoYXJlZEJ1ZmZlcjo6Y3JlYXRlV2l0aENvbnRlbnRzT2ZGaWxlKGNvbnN0IFN0cmluZyYgZmkK ICAgICBpZiAocmVzdWx0LT5tX2J1ZmZlci5zaXplKCkgIT0gZmlsZS5zaXplKCkpCiAgICAgICAg IHJldHVybiAwOwogCisgICAgcmVzdWx0LT5tX3NpemUgPSByZXN1bHQtPm1fYnVmZmVyLnNpemUo KTsKKwogICAgIGZpbGUucmVhZChyZXN1bHQtPm1fYnVmZmVyLmRhdGEoKSwgcmVzdWx0LT5tX2J1 ZmZlci5zaXplKCkpOwogICAgIHJldHVybiByZXN1bHQucmVsZWFzZSgpOwogfQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcCBiL1dlYkNvcmUvcGxh dGZvcm0vd2luL1NoYXJlZEJ1ZmZlcldpbi5jcHAKaW5kZXggMTgzOWM5OS4uYTk1ZDU5MCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS93aW4vU2hhcmVkQnVmZmVyV2luLmNwcAorKysgYi9X ZWJDb3JlL3BsYXRmb3JtL3dpbi9TaGFyZWRCdWZmZXJXaW4uY3BwCkBAIC01Nyw2ICs1Nyw4IEBA IFBhc3NSZWZQdHI8U2hhcmVkQnVmZmVyPiBTaGFyZWRCdWZmZXI6OmNyZWF0ZVdpdGhDb250ZW50 c09mRmlsZShjb25zdCBTdHJpbmcmIGZpCiAgICAgICAgIGdvdG8gZXhpdDsKICAgICB9CiAKKyAg ICByZXN1bHQtPm1fc2l6ZSA9IHJlc3VsdC0+bV9idWZmZXIuc2l6ZSgpOworCiAgICAgaWYgKGZy ZWFkKHJlc3VsdC0+bV9idWZmZXIuZGF0YSgpLCAxLCBmaWxlU3RhdC5zdF9zaXplLCBmaWxlRGVz Y3JpcHRvcikgIT0gZmlsZVN0YXQuc3Rfc2l6ZSkKICAgICAgICAgTE9HX0VSUk9SKCJGYWlsZWQg dG8gZnVsbHkgcmVhZCBjb250ZW50cyBvZiBmaWxlICVzIC0gZXJybm8oJWkpIiwgZmlsZVBhdGgu YXNjaWkoKS5kYXRhKCksIGVycm5vKTsKIAo= 45889 2010-01-05 07:31:45 -0800 2010-01-05 08:41:25 -0800 (2) make PNG image decoder read from segmented SharedBuffer 33178-2.patch text/plain 7906 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZmUzZmUxOS4uMzBmMmMxMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0wMS0wNSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIE1ha2UgUE5HIGltYWdlIGRlY29kZXIgd29yayB3aXRoIHNlZ21lbnRl ZCBTaGFyZWRCdWZmZXIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTMzMTc4CisKKyAgICAgICAgKiBwbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURl Y29kZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VEZWNvZGVyOjpjcmVhdGUpOgorICAg ICAgICAqIHBsYXRmb3JtL2ltYWdlLWRlY29kZXJzL0ltYWdlRGVjb2Rlci5oOgorICAgICAgICAo V2ViQ29yZTo6SW1hZ2VEZWNvZGVyOjpJbWFnZURlY29kZXIpOgorICAgICAgICAoV2ViQ29yZTo6 SW1hZ2VEZWNvZGVyOjppc0FsbERhdGFSZWNlaXZlZCk6CisgICAgICAgIChXZWJDb3JlOjpJbWFn ZURlY29kZXI6OnNldERhdGEpOgorICAgICAgICAqIHBsYXRmb3JtL2ltYWdlLWRlY29kZXJzL3Bu Zy9QTkdJbWFnZURlY29kZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UE5HSW1hZ2VSZWFkZXI6 OlBOR0ltYWdlUmVhZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBOR0ltYWdlUmVhZGVyOjpjbG9z ZSk6CisgICAgICAgIChXZWJDb3JlOjpQTkdJbWFnZVJlYWRlcjo6Y3VycmVudEJ1ZmZlclNpemUp OgorICAgICAgICAoV2ViQ29yZTo6UE5HSW1hZ2VSZWFkZXI6OnNldENvbXBsZXRlKToKKyAgICAg ICAgKFdlYkNvcmU6OlBOR0ltYWdlUmVhZGVyOjpkZWNvZGUpOgorICAgICAgICAoV2ViQ29yZTo6 UE5HSW1hZ2VEZWNvZGVyOjpkZWNvZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE5HSW1hZ2VEZWNv ZGVyOjpoZWFkZXJBdmFpbGFibGUpOgorICAgICAgICAoV2ViQ29yZTo6UE5HSW1hZ2VEZWNvZGVy OjpwbmdDb21wbGV0ZSk6CisKIDIwMTAtMDEtMDQgIFlvbmcgTGkgIDx5b2xpQHJpbS5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL2ltYWdlLWRlY29kZXJzL0ltYWdlRGVjb2Rlci5jcHAgYi9XZWJDb3JlL3BsYXRmb3Jt L2ltYWdlLWRlY29kZXJzL0ltYWdlRGVjb2Rlci5jcHAKaW5kZXggYTE2Yjk0MC4uOTliYzE0YyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9JbWFnZURlY29kZXIu Y3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvSW1hZ2VEZWNvZGVyLmNw cApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDgtMjAwOSBUb3JjaCBN b2JpbGUsIEluYy4KKyAqIENvcHlyaWdodCAoQykgUmVzZWFyY2ggSW4gTW90aW9uIExpbWl0ZWQg MjAwOS0yMDEwLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqICBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiAgbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAg LTM4LDEzICszOSwxNCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIEltYWdlRGVjb2RlciogSW1h Z2VEZWNvZGVyOjpjcmVhdGUoY29uc3QgU2hhcmVkQnVmZmVyJiBkYXRhKQogeworICAgIGNvbnN0 IGNoYXIqIGNvbnRlbnRzOworICAgIHVuc2lnbmVkIGxlbmd0aCA9IGRhdGEuZ2V0U29tZURhdGEo JmNvbnRlbnRzLCAwKTsKKwogICAgIC8vIFdlIG5lZWQgYXQgbGVhc3QgNCBieXRlcyB0byBmaWd1 cmUgb3V0IHdoYXQga2luZCBvZiBpbWFnZSB3ZSdyZSBkZWFsaW5nIHdpdGguCi0gICAgaW50IGxl bmd0aCA9IGRhdGEuc2l6ZSgpOwogICAgIGlmIChsZW5ndGggPCA0KQogICAgICAgICByZXR1cm4g MDsKIAotICAgIGNvbnN0IHVuc2lnbmVkIGNoYXIqIHVDb250ZW50cyA9IChjb25zdCB1bnNpZ25l ZCBjaGFyKilkYXRhLmRhdGEoKTsKLSAgICBjb25zdCBjaGFyKiBjb250ZW50cyA9IGRhdGEuZGF0 YSgpOworICAgIGNvbnN0IHVuc2lnbmVkIGNoYXIqIHVDb250ZW50cyA9IHJlaW50ZXJwcmV0X2Nh c3Q8Y29uc3QgdW5zaWduZWQgY2hhcio+KGNvbnRlbnRzKTsKIAogICAgIC8vIEdJRnMgYmVnaW4g d2l0aCBHSUY4KDcgb3IgOSkuCiAgICAgaWYgKHN0cm5jbXAoY29udGVudHMsICJHSUY4IiwgNCkg PT0gMCkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvSW1hZ2VE ZWNvZGVyLmggYi9XZWJDb3JlL3BsYXRmb3JtL2ltYWdlLWRlY29kZXJzL0ltYWdlRGVjb2Rlci5o CmluZGV4IGRlMjQ4MjguLjQzNTVmNjMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vaW1h Z2UtZGVjb2RlcnMvSW1hZ2VEZWNvZGVyLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1k ZWNvZGVycy9JbWFnZURlY29kZXIuaApAQCAtMSw2ICsxLDcgQEAKIC8qCiAgKiBDb3B5cmlnaHQg KEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKiBD b3B5cmlnaHQgKEMpIDIwMDgtMjAwOSBUb3JjaCBNb2JpbGUsIEluYy4KKyAqIENvcHlyaWdodCAo QykgUmVzZWFyY2ggSW4gTW90aW9uIExpbWl0ZWQgMjAwOS0yMDEwLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLgogICogQ29weXJpZ2h0IChDKSAyMDA5IE5va2lhIENvcnBvcmF0aW9uIGFuZC9vciBpdHMg c3Vic2lkaWFyeSgtaWVzKQogICoKICAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dApAQCAtMjAwLDYgKzIwMSw3IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgSW1hZ2VEZWNvZGVyKCkKICAgICAgICAgICAgIDog bV9mYWlsZWQoZmFsc2UpCiAgICAgICAgICAgICAsIG1fc2l6ZUF2YWlsYWJsZShmYWxzZSkKKyAg ICAgICAgICAgICwgbV9pc0FsbERhdGFSZWNlaXZlZChmYWxzZSkKICNpZiBFTkFCTEUoSU1BR0Vf REVDT0RFUl9ET1dOX1NBTVBMSU5HKQogICAgICAgICAgICAgLCBtX21heE51bVBpeGVscygtMSkK ICAgICAgICAgICAgICwgbV9zY2FsZWQoZmFsc2UpCkBAIC0yMTgsNyArMjIwLDEyIEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgdmlydHVhbCBTdHJpbmcgZmlsZW5hbWVFeHRlbnNpb24o KSBjb25zdCA9IDA7CiAKICAgICAgICAgLy8gQWxsIHNwZWNpZmljIGRlY29kZXIgcGx1Z2lucyBt dXN0IGRvIHNvbWV0aGluZyB3aXRoIHRoZSBkYXRhIHRoZXkgYXJlIGdpdmVuLgotICAgICAgICB2 aXJ0dWFsIHZvaWQgc2V0RGF0YShTaGFyZWRCdWZmZXIqIGRhdGEsIGJvb2wgYWxsRGF0YVJlY2Vp dmVkKSB7IG1fZGF0YSA9IGRhdGE7IH0KKyAgICAgICAgYm9vbCBpc0FsbERhdGFSZWNlaXZlZCgp IGNvbnN0IHsgcmV0dXJuIG1faXNBbGxEYXRhUmVjZWl2ZWQ7IH0KKyAgICAgICAgdmlydHVhbCB2 b2lkIHNldERhdGEoU2hhcmVkQnVmZmVyKiBkYXRhLCBib29sIGFsbERhdGFSZWNlaXZlZCkKKyAg ICAgICAgeworICAgICAgICAgICAgbV9kYXRhID0gZGF0YTsKKyAgICAgICAgICAgIG1faXNBbGxE YXRhUmVjZWl2ZWQgPSBhbGxEYXRhUmVjZWl2ZWQ7CisgICAgICAgIH0KIAogICAgICAgICAvLyBX aGV0aGVyIG9yIG5vdCB0aGUgc2l6ZSBpbmZvcm1hdGlvbiBoYXMgYmVlbiBkZWNvZGVkIHlldC4g VGhpcyBkZWZhdWx0CiAgICAgICAgIC8vIGltcGxlbWVudGF0aW9uIGp1c3QgcmV0dXJucyB0cnVl IGlmIHRoZSBzaXplIGhhcyBiZWVuIHNldCBhbmQgd2UgaGF2ZSBub3QKQEAgLTMyNiw2ICszMzMs NyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgSW50U2l6ZSBtX3NpemU7CiAgICAg ICAgIGJvb2wgbV9zaXplQXZhaWxhYmxlOworICAgICAgICBib29sIG1faXNBbGxEYXRhUmVjZWl2 ZWQ7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy9wbmcvUE5HSW1hZ2VEZWNvZGVyLmNwcCBiL1dlYkNv cmUvcGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMvcG5nL1BOR0ltYWdlRGVjb2Rlci5jcHAKaW5kZXgg MmVhMDEyYi4uZTc4NmQ4YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNv ZGVycy9wbmcvUE5HSW1hZ2VEZWNvZGVyLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2ltYWdl LWRlY29kZXJzL3BuZy9QTkdJbWFnZURlY29kZXIuY3BwCkBAIC0xLDYgKzEsNyBAQAogLyoKICAq IENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICogQ29weXJpZ2h0IChD KSAyMDA3LTIwMDkgVG9yY2ggTW9iaWxlLCBJbmMuCisgKiBDb3B5cmlnaHQgKEMpIFJlc2VhcmNo IEluIE1vdGlvbiBMaW1pdGVkIDIwMDktMjAxMC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICAqCiAg KiBQb3J0aW9ucyBhcmUgQ29weXJpZ2h0IChDKSAyMDAxIG1vemlsbGEub3JnCiAgKgpAQCAtNzUs NiArNzYsOCBAQCBwdWJsaWM6CiAgICAgICAgICwgbV9kZWNvZGluZ1NpemVPbmx5KGZhbHNlKQog ICAgICAgICAsIG1faW50ZXJsYWNlQnVmZmVyKDApCiAgICAgICAgICwgbV9oYXNBbHBoYSgwKQor ICAgICAgICAsIG1fam9iQ29tcGxldGUoZmFsc2UpCisgICAgICAgICwgbV9jdXJyZW50QnVmZmVy U2l6ZSgwKQogICAgIHsKICAgICAgICAgbV9wbmcgPSBwbmdfY3JlYXRlX3JlYWRfc3RydWN0KFBO R19MSUJQTkdfVkVSX1NUUklORywgMCwgZGVjb2RpbmdGYWlsZWQsIGRlY29kaW5nV2FybmluZyk7 CiAgICAgICAgIG1faW5mbyA9IHBuZ19jcmVhdGVfaW5mb19zdHJ1Y3QobV9wbmcpOwpAQCAtOTIs OSArOTUsMTQgQEAgcHVibGljOgogICAgICAgICBkZWxldGUgW11tX2ludGVybGFjZUJ1ZmZlcjsK ICAgICAgICAgbV9pbnRlcmxhY2VCdWZmZXIgPSAwOwogICAgICAgICBtX3JlYWRPZmZzZXQgPSAw OworICAgICAgICBtX2pvYkNvbXBsZXRlID0gZmFsc2U7CiAgICAgfQogCi0gICAgdm9pZCBkZWNv ZGUoY29uc3QgVmVjdG9yPGNoYXI+JiBkYXRhLCBib29sIHNpemVPbmx5KQorICAgIHVuc2lnbmVk IGN1cnJlbnRCdWZmZXJTaXplKCkgY29uc3QgeyByZXR1cm4gbV9jdXJyZW50QnVmZmVyU2l6ZTsg fQorCisgICAgdm9pZCBzZXRDb21wbGV0ZSgpIHsgbV9qb2JDb21wbGV0ZSA9IHRydWU7IH0KKwor ICAgIHZvaWQgZGVjb2RlKGNvbnN0IFNoYXJlZEJ1ZmZlciYgZGF0YSwgYm9vbCBzaXplT25seSkK ICAgICB7CiAgICAgICAgIG1fZGVjb2RpbmdTaXplT25seSA9IHNpemVPbmx5OwogCkBAIC0xMDQs MTMgKzExMiwyMyBAQCBwdWJsaWM6CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KIAot ICAgICAgICAvLyBHbyBhaGVhZCBhbmQgYXNzdW1lIHdlIGNvbnN1bWVkIGFsbCB0aGUgZGF0YS4g IElmIHdlIGNvbnN1bWUgbGVzcywgdGhlCi0gICAgICAgIC8vIGNhbGxiYWNrIHdpbGwgYWRqdXN0 IG91ciByZWFkIG9mZnNldCBhY2NvcmRpbmdseS4gIERvIG5vdCBhdHRlbXB0IHRvIGFkanVzdCB0 aGUKLSAgICAgICAgLy8gb2Zmc2V0IGFmdGVyIHBuZ19wcm9jZXNzX2RhdGEgcmV0dXJucy4KLSAg ICAgICAgdW5zaWduZWQgb2Zmc2V0ID0gbV9yZWFkT2Zmc2V0OwotICAgICAgICB1bnNpZ25lZCBy ZW1haW5pbmcgPSBkYXRhLnNpemUoKSAtIG1fcmVhZE9mZnNldDsKLSAgICAgICAgbV9yZWFkT2Zm c2V0ID0gZGF0YS5zaXplKCk7Ci0gICAgICAgIHBuZ19wcm9jZXNzX2RhdGEobV9wbmcsIG1faW5m bywgKHBuZ19ieXRlcCkoZGF0YS5kYXRhKCkpICsgb2Zmc2V0LCByZW1haW5pbmcpOworICAgICAg ICBQTkdJbWFnZURlY29kZXIqIGRlY29kZXIgPSBzdGF0aWNfY2FzdDxQTkdJbWFnZURlY29kZXIq PihwbmdfZ2V0X3Byb2dyZXNzaXZlX3B0cihtX3BuZykpOworICAgICAgICBmb3IgKDs7KSB7Cisg ICAgICAgICAgICBjb25zdCBjaGFyKiBzZWdtZW50OworICAgICAgICAgICAgdW5zaWduZWQgc2Vn bWVudExlbmd0aCA9IGRhdGEuZ2V0U29tZURhdGEoc2VnbWVudCwgbV9yZWFkT2Zmc2V0KTsKKyAg ICAgICAgICAgIGlmICghc2VnbWVudExlbmd0aCkgeworICAgICAgICAgICAgICAgIGlmICghbV9q b2JDb21wbGV0ZSkgeworICAgICAgICAgICAgICAgICAgICBpZiAoZGVjb2Rlci0+aXNBbGxEYXRh UmVjZWl2ZWQoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIGRlY29kZXItPnBuZ0NvbXBsZXRl KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAg ICAgfQorICAgICAgICAgICAgbV9yZWFkT2Zmc2V0ICs9IHNlZ21lbnRMZW5ndGg7CisgICAgICAg ICAgICBtX2N1cnJlbnRCdWZmZXJTaXplID0gbV9yZWFkT2Zmc2V0OworICAgICAgICAgICAgcG5n X3Byb2Nlc3NfZGF0YShtX3BuZywgbV9pbmZvLCByZWludGVycHJldF9jYXN0PHBuZ19ieXRlcD4o Y29uc3RfY2FzdDxjaGFyKj4oc2VnbWVudCkpLCBzZWdtZW50TGVuZ3RoKTsKKyAgICAgICAgICAg IGlmICgoc2l6ZU9ubHkgJiYgZGVjb2Rlci0+aXNTaXplQXZhaWxhYmxlKCkpIHx8IG1fam9iQ29t cGxldGUpCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH07CiAgICAgfQogCiAgICAg Ym9vbCBkZWNvZGluZ1NpemVPbmx5KCkgY29uc3QgeyByZXR1cm4gbV9kZWNvZGluZ1NpemVPbmx5 OyB9CkBAIC0xMzMsNiArMTUxLDggQEAgcHJpdmF0ZToKICAgICBwbmdfaW5mb3AgbV9pbmZvOwog ICAgIHBuZ19ieXRlcCBtX2ludGVybGFjZUJ1ZmZlcjsKICAgICBib29sIG1faGFzQWxwaGE7Cisg ICAgYm9vbCBtX2pvYkNvbXBsZXRlOworICAgIHVuc2lnbmVkIG1fY3VycmVudEJ1ZmZlclNpemU7 CiB9OwogCiBQTkdJbWFnZURlY29kZXI6OlBOR0ltYWdlRGVjb2RlcigpCkBAIC0xODksNyArMjA5 LDcgQEAgdm9pZCBQTkdJbWFnZURlY29kZXI6OmRlY29kZShib29sIHNpemVPbmx5KQogICAgIGlm IChtX2ZhaWxlZCkKICAgICAgICAgcmV0dXJuOwogCi0gICAgbV9yZWFkZXItPmRlY29kZShtX2Rh dGEtPmJ1ZmZlcigpLCBzaXplT25seSk7CisgICAgbV9yZWFkZXItPmRlY29kZSgqbV9kYXRhLCBz aXplT25seSk7CiAgICAgCiAgICAgaWYgKG1fZmFpbGVkIHx8ICghbV9mcmFtZUJ1ZmZlckNhY2hl LmlzRW1wdHkoKSAmJiBtX2ZyYW1lQnVmZmVyQ2FjaGVbMF0uc3RhdHVzKCkgPT0gUkdCQTMyQnVm ZmVyOjpGcmFtZUNvbXBsZXRlKSkgewogICAgICAgICBkZWxldGUgbV9yZWFkZXI7CkBAIC0yOTcs NyArMzE3LDcgQEAgdm9pZCBQTkdJbWFnZURlY29kZXI6OmhlYWRlckF2YWlsYWJsZSgpCiAKICAg ICBpZiAocmVhZGVyKCktPmRlY29kaW5nU2l6ZU9ubHkoKSkgewogICAgICAgICAvLyBJZiB3ZSBv bmx5IG5lZWRlZCB0aGUgc2l6ZSwgaGFsdCB0aGUgcmVhZGVyLiAgICAgCi0gICAgICAgIHJlYWRl cigpLT5zZXRSZWFkT2Zmc2V0KG1fZGF0YS0+c2l6ZSgpIC0gcG5nLT5idWZmZXJfc2l6ZSk7Cisg ICAgICAgIHJlYWRlcigpLT5zZXRSZWFkT2Zmc2V0KHJlYWRlcigpLT5jdXJyZW50QnVmZmVyU2l6 ZSgpIC0gcG5nLT5idWZmZXJfc2l6ZSk7CiAgICAgICAgIHBuZy0+YnVmZmVyX3NpemUgPSAwOwog ICAgIH0KIH0KQEAgLTQyMyw2ICs0NDMsOCBAQCB2b2lkIHBuZ0NvbXBsZXRlKHBuZ19zdHJ1Y3Rw IHBuZywgcG5nX2luZm9wIGluZm8pCiAKIHZvaWQgUE5HSW1hZ2VEZWNvZGVyOjpwbmdDb21wbGV0 ZSgpCiB7CisgICAgbV9yZWFkZXItPnNldENvbXBsZXRlKCk7CisKICAgICBpZiAobV9mcmFtZUJ1 ZmZlckNhY2hlLmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuOwogCg== 45890 2010-01-05 07:41:05 -0800 2010-01-05 09:32:05 -0800 Fix a bug in the first commit (introduced when fixing coding style) 33178-fix.patch text/plain 1522 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg ZmUzZmUxOS4uNzg0MGQxMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMC0wMS0wNSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEZpeCBhbiBvYnZpb3VzIGJ1ZyBpbiBwcmV2aW91cyBjb21taXQgKHI1 Mjc5NSkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMz MTc4CisKKyAgICAgICAgKiBwbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaDoKKyAgICAgICAgKFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcjo6aXNFbXB0eSk6CisgICAgICAgICogcGxhdGZvcm0vY2YvU2hhcmVk QnVmZmVyQ0YuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjptYXliZVRyYW5z ZmVyUGxhdGZvcm1EYXRhKToKKwogMjAxMC0wMS0wNCAgWW9uZyBMaSAgPHlvbGlAcmltLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vU2hhcmVkQnVmZmVyLmggYi9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5o CmluZGV4IDc1MGE1OWEuLmQ4MWEyZjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vU2hh cmVkQnVmZmVyLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaApAQCAtODYs NyArODYsNyBAQCBwdWJsaWM6CiAgICAgLy8gZm9yIGJldHRlciBwZXJmb3JtYW5jZS4KICAgICBj b25zdCBWZWN0b3I8Y2hhcj4mIGJ1ZmZlcigpIGNvbnN0OwogCi0gICAgYm9vbCBpc0VtcHR5KCkg Y29uc3QgeyByZXR1cm4gc2l6ZSgpOyB9CisgICAgYm9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1 cm4gIXNpemUoKTsgfQogCiAgICAgdm9pZCBhcHBlbmQoY29uc3QgY2hhciosIGludCk7CiAgICAg dm9pZCBjbGVhcigpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9jZi9TaGFyZWRCdWZm ZXJDRi5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL2NmL1NoYXJlZEJ1ZmZlckNGLmNwcAppbmRleCBj OTZiZmNjLi5kYTE2NmM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL2NmL1NoYXJlZEJ1 ZmZlckNGLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL2NmL1NoYXJlZEJ1ZmZlckNGLmNwcApA QCAtNzYsNyArNzYsNyBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6bWF5YmVUcmFuc2ZlclBsYXRmb3Jt RGF0YSgpCiAgICAgaWYgKCFtX2NmRGF0YSkKICAgICAgICAgcmV0dXJuOwogICAgIAotICAgIEFT U0VSVChtX3NpemUgPT0gMCk7CisgICAgQVNTRVJUKCFtX3NpemUpOwogICAgICAgICAKICAgICBh cHBlbmQoKGNvbnN0IGNoYXIqKUNGRGF0YUdldEJ5dGVQdHIobV9jZkRhdGEuZ2V0KCkpLCBDRkRh dGFHZXRMZW5ndGgobV9jZkRhdGEuZ2V0KCkpKTsKICAgICAgICAgCg== 45894 2010-01-05 08:41:25 -0800 2010-01-05 09:00:47 -0800 fix build warnings 33178-fix-build.patch text/plain 1402 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YmY3MDljNi4uMGU5NDIzZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsNSArMSwxNSBAQAogMjAxMC0wMS0wNSAgWW9uZyBMaSAgPHlv bmcubGlAdG9yY2htb2JpbGUuY29tPgogCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEZpeCAgYnVpbGQgd2FybmluZ3MgYmxpbmRseQorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzMxNzgKKworICAgICAgICAqIHBs YXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpTaGFyZWRCdWZmZXI6 OmFwcGVuZCk6CisKKzIwMTAtMDEtMDUgIFlvbmcgTGkgIDx5b25nLmxpQHRvcmNobW9iaWxlLmNv bT4KKwogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KIAogICAgICAgICBGaXggYW4g b2J2aW91cyBidWcgYW5kIGJ1aWxkIGVycm9ycyBpbiBwcmV2aW91cyBjb21taXQgKHI1Mjc5NSkK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcCBiL1dlYkNvcmUv cGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcAppbmRleCA1MWE0MDBmLi4xZTY2YjI3IDEwMDY0NAot LS0gYS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKKysrIGIvV2ViQ29yZS9wbGF0 Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCkBAIC0xNDEsMTQgKzE0MSwxNCBAQCB2b2lkIFNoYXJlZEJ1 ZmZlcjo6YXBwZW5kKGNvbnN0IGNoYXIqIGRhdGEsIGludCBsZW5ndGgpCiAKICAgICBmb3IgKDs7 KSB7CiAgICAgICAgIG1lbWNweShzZWdtZW50LCBkYXRhLCBieXRlc1RvQ29weSk7Ci0gICAgICAg IGlmIChsZW5ndGggPT0gYnl0ZXNUb0NvcHkpCisgICAgICAgIGlmIChzdGF0aWNfY2FzdDx1bnNp Z25lZD4obGVuZ3RoKSA9PSBieXRlc1RvQ29weSkKICAgICAgICAgICAgIGJyZWFrOwogCi0gICAg ICAgIGxlbmd0aCAtPSBieXRlc1RvQ29weTsKKyAgICAgICAgbGVuZ3RoIC09IHN0YXRpY19jYXN0 PGludD4oYnl0ZXNUb0NvcHkpOwogICAgICAgICBkYXRhICs9IGJ5dGVzVG9Db3B5OwogICAgICAg ICBzZWdtZW50ID0gYWxsb2NhdGVTZWdtZW50KCk7CiAgICAgICAgIG1fc2VnbWVudHMuYXBwZW5k KHNlZ21lbnQpOwotICAgICAgICBieXRlc1RvQ29weSA9IGxlbmd0aCA8IHNlZ21lbnRTaXplID8g bGVuZ3RoIDogc2VnbWVudFNpemU7CisgICAgICAgIGJ5dGVzVG9Db3B5ID0gc3RhdGljX2Nhc3Q8 dW5zaWduZWQ+KGxlbmd0aCkgPCBzZWdtZW50U2l6ZSA/IHN0YXRpY19jYXN0PHVuc2lnbmVkPihs ZW5ndGgpIDogc2VnbWVudFNpemU7CiAgICAgfQogfQogCg== 45895 2010-01-05 09:00:47 -0800 2010-01-05 09:30:44 -0800 fix build warning by change append(char*, int) to append(char*, unsigned) 33178-fix-build.patch text/plain 1876 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YmY3MDljNi4uNDA5ZmFkOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMC0wMS0wNSAgWW9uZyBMaSAgPHlv bGlAcmltLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBGaXggIGJ1aWxkIHdhcm5pbmdzIGJsaW5kbHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMzMTc4CisKKyAgICAgICAgKiBwbGF0Zm9ybS9TaGFy ZWRCdWZmZXIuY3BwOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAg ICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjphcHBlbmQpOgorCiAyMDEwLTAxLTA1ICBZb25nIExp ICA8eW9uZy5saUB0b3JjaG1vYmlsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4g QWRsZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAgYi9X ZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggNTFhNDAwZi4uMDljYjYzMiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcApAQCAtMTE0LDcgKzExNCw3IEBAIGNvbnN0IGNo YXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiAgICAgcmV0dXJuIGJ1ZmZlcigpLmRhdGEo KTsKIH0KIAotdm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQg bGVuZ3RoKQordm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBjaGFyKiBkYXRhLCB1bnNp Z25lZCBsZW5ndGgpCiB7CiAgICAgQVNTRVJUKCFtX3B1cmdlYWJsZUJ1ZmZlcik7CiAKQEAgLTEz Nyw3ICsxMzcsNyBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBwZW5kKGNvbnN0IGNoYXIqIGRhdGEs IGludCBsZW5ndGgpCiAgICAgICAgIHNlZ21lbnQgPSBtX3NlZ21lbnRzLmxhc3QoKSArIHBvc2l0 aW9uSW5TZWdtZW50OwogCiAgICAgdW5zaWduZWQgc2VnbWVudEZyZWVTcGFjZSA9IHNlZ21lbnRT aXplIC0gcG9zaXRpb25JblNlZ21lbnQ7Ci0gICAgdW5zaWduZWQgYnl0ZXNUb0NvcHkgPSBzdGF0 aWNfY2FzdDx1bnNpZ25lZD4obGVuZ3RoKSA8IHNlZ21lbnRGcmVlU3BhY2UgPyBzdGF0aWNfY2Fz dDx1bnNpZ25lZD4obGVuZ3RoKSA6IHNlZ21lbnRGcmVlU3BhY2U7CisgICAgdW5zaWduZWQgYnl0 ZXNUb0NvcHkgPSBsZW5ndGggPCBzZWdtZW50RnJlZVNwYWNlID8gbGVuZ3RoIDogc2VnbWVudEZy ZWVTcGFjZTsKIAogICAgIGZvciAoOzspIHsKICAgICAgICAgbWVtY3B5KHNlZ21lbnQsIGRhdGEs IGJ5dGVzVG9Db3B5KTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVy LmggYi9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oCmluZGV4IGQ4MWEyZjcuLmE1NTY2 ZjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuaApAQCAtODgsNyArODgsNyBAQCBwdWJsaWM6CiAK ICAgICBib29sIGlzRW1wdHkoKSBjb25zdCB7IHJldHVybiAhc2l6ZSgpOyB9CiAKLSAgICB2b2lk IGFwcGVuZChjb25zdCBjaGFyKiwgaW50KTsKKyAgICB2b2lkIGFwcGVuZChjb25zdCBjaGFyKiwg dW5zaWduZWQpOwogICAgIHZvaWQgY2xlYXIoKTsKICAgICBjb25zdCBjaGFyKiBwbGF0Zm9ybURh dGEoKSBjb25zdDsKICAgICB1bnNpZ25lZCBwbGF0Zm9ybURhdGFTaXplKCkgY29uc3Q7Cg== 45900 2010-01-05 09:32:05 -0800 2010-01-05 10:11:15 -0800 fix build warnings 33178-fix-build.patch text/plain 2710 yong.li.webkit ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YmY3MDljNi4uNDA5ZmFkOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMC0wMS0wNSAgWW9uZyBMaSAgPHlv bGlAcmltLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBGaXggIGJ1aWxkIHdhcm5pbmdzIGJsaW5kbHkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTMzMTc4CisKKyAgICAgICAgKiBwbGF0Zm9ybS9TaGFy ZWRCdWZmZXIuY3BwOgorICAgICAgICAqIHBsYXRmb3JtL1NoYXJlZEJ1ZmZlci5oOgorICAgICAg ICAoV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjphcHBlbmQpOgorCiAyMDEwLTAxLTA1ICBZb25nIExp ICA8eW9uZy5saUB0b3JjaG1vYmlsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4g QWRsZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAgYi9X ZWJDb3JlL3BsYXRmb3JtL1NoYXJlZEJ1ZmZlci5jcHAKaW5kZXggNTFhNDAwZi4uNDBlNGRiMyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRCdWZmZXIuY3BwCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmNwcApAQCAtMTE0LDcgKzExNCw3IEBAIGNvbnN0IGNo YXIqIFNoYXJlZEJ1ZmZlcjo6ZGF0YSgpIGNvbnN0CiAgICAgcmV0dXJuIGJ1ZmZlcigpLmRhdGEo KTsKIH0KIAotdm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBjaGFyKiBkYXRhLCBpbnQg bGVuZ3RoKQordm9pZCBTaGFyZWRCdWZmZXI6OmFwcGVuZChjb25zdCBjaGFyKiBkYXRhLCB1bnNp Z25lZCBsZW5ndGgpCiB7CiAgICAgQVNTRVJUKCFtX3B1cmdlYWJsZUJ1ZmZlcik7CiAKQEAgLTEz Nyw3ICsxMzcsNyBAQCB2b2lkIFNoYXJlZEJ1ZmZlcjo6YXBwZW5kKGNvbnN0IGNoYXIqIGRhdGEs IGludCBsZW5ndGgpCiAgICAgICAgIHNlZ21lbnQgPSBtX3NlZ21lbnRzLmxhc3QoKSArIHBvc2l0 aW9uSW5TZWdtZW50OwogCiAgICAgdW5zaWduZWQgc2VnbWVudEZyZWVTcGFjZSA9IHNlZ21lbnRT aXplIC0gcG9zaXRpb25JblNlZ21lbnQ7Ci0gICAgdW5zaWduZWQgYnl0ZXNUb0NvcHkgPSBzdGF0 aWNfY2FzdDx1bnNpZ25lZD4obGVuZ3RoKSA8IHNlZ21lbnRGcmVlU3BhY2UgPyBzdGF0aWNfY2Fz dDx1bnNpZ25lZD4obGVuZ3RoKSA6IHNlZ21lbnRGcmVlU3BhY2U7CisgICAgdW5zaWduZWQgYnl0 ZXNUb0NvcHkgPSBzdGQ6Om1pbihsZW5ndGgsIHNlZ21lbnRGcmVlU3BhY2UpOwogCiAgICAgZm9y ICg7OykgewogICAgICAgICBtZW1jcHkoc2VnbWVudCwgZGF0YSwgYnl0ZXNUb0NvcHkpOwpAQCAt MTQ4LDcgKzE0OCw3IEBAIHZvaWQgU2hhcmVkQnVmZmVyOjphcHBlbmQoY29uc3QgY2hhciogZGF0 YSwgaW50IGxlbmd0aCkKICAgICAgICAgZGF0YSArPSBieXRlc1RvQ29weTsKICAgICAgICAgc2Vn bWVudCA9IGFsbG9jYXRlU2VnbWVudCgpOwogICAgICAgICBtX3NlZ21lbnRzLmFwcGVuZChzZWdt ZW50KTsKLSAgICAgICAgYnl0ZXNUb0NvcHkgPSBsZW5ndGggPCBzZWdtZW50U2l6ZSA/IGxlbmd0 aCA6IHNlZ21lbnRTaXplOworICAgICAgICBieXRlc1RvQ29weSA9IHN0ZDo6bWluKGxlbmd0aCwg c2VnbWVudFNpemUpOwogICAgIH0KIH0KIApAQCAtMTk2LDcgKzE5Niw3IEBAIGNvbnN0IFZlY3Rv cjxjaGFyPiYgU2hhcmVkQnVmZmVyOjpidWZmZXIoKSBjb25zdAogICAgICAgICBjaGFyKiBkZXN0 aW5hdGlvbiA9IG1fYnVmZmVyLmRhdGEoKSArIGJ1ZmZlclNpemU7CiAgICAgICAgIHVuc2lnbmVk IGJ5dGVzTGVmdCA9IG1fc2l6ZSAtIGJ1ZmZlclNpemU7CiAgICAgICAgIGZvciAodW5zaWduZWQg aSA9IDA7IGkgPCBtX3NlZ21lbnRzLnNpemUoKTsgKytpKSB7Ci0gICAgICAgICAgICB1bnNpZ25l ZCBieXRlc1RvQ29weSA9IGJ5dGVzTGVmdCA8IHNlZ21lbnRTaXplID8gYnl0ZXNMZWZ0IDogc2Vn bWVudFNpemU7CisgICAgICAgICAgICB1bnNpZ25lZCBieXRlc1RvQ29weSA9IHN0ZDo6bWluKGJ5 dGVzTGVmdCwgc2VnbWVudFNpemUpOwogICAgICAgICAgICAgbWVtY3B5KGRlc3RpbmF0aW9uLCBt X3NlZ21lbnRzW2ldLCBieXRlc1RvQ29weSk7CiAgICAgICAgICAgICBkZXN0aW5hdGlvbiArPSBi eXRlc1RvQ29weTsKICAgICAgICAgICAgIGJ5dGVzTGVmdCAtPSBieXRlc1RvQ29weTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmggYi9XZWJDb3JlL3BsYXRmb3Jt L1NoYXJlZEJ1ZmZlci5oCmluZGV4IGQ4MWEyZjcuLmE1NTY2ZjIgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGxhdGZvcm0vU2hhcmVkQnVmZmVyLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9TaGFyZWRC dWZmZXIuaApAQCAtODgsNyArODgsNyBAQCBwdWJsaWM6CiAKICAgICBib29sIGlzRW1wdHkoKSBj b25zdCB7IHJldHVybiAhc2l6ZSgpOyB9CiAKLSAgICB2b2lkIGFwcGVuZChjb25zdCBjaGFyKiwg aW50KTsKKyAgICB2b2lkIGFwcGVuZChjb25zdCBjaGFyKiwgdW5zaWduZWQpOwogICAgIHZvaWQg Y2xlYXIoKTsKICAgICBjb25zdCBjaGFyKiBwbGF0Zm9ybURhdGEoKSBjb25zdDsKICAgICB1bnNp Z25lZCBwbGF0Zm9ybURhdGFTaXplKCkgY29uc3Q7Cg==