71242 2011-10-31 15:21:08 -0700 [chromium] WebKitMutationObserver::deliverAllMutations should be exposed through the Chromium API 2011-12-02 11:39:38 -0800 1 1 1 Unclassified WebKit WebKit Misc. 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 73372 68729 1 adamk adamk agl arv fishd levin rafaelw webkit.review.bot oldest_to_newest 493530 0 adamk 2011-10-31 15:21:08 -0700 For MutationObservers, besides the delivery at the end-of-microtask, there are also cases where we need to deliver at the end of a task in a case where there was no microtask (no script) involved in a DOM mutation (e.g., when user input triggers a DOM modification inside a contentEditable element). The embedder is in the right position to act at the end of every task, while WebCore is not. This means exposing WebKitMutationObserver::deliverAllMutations() through the API. The main question here is one of naming: should this hook be something like WebMutationObserver::deliverAllMutations()? Or would we be better off with runEndOfTaskWork() (what class would export that method?). 493736 1 fishd 2011-10-31 21:43:46 -0700 I'd prefer a more generalized micro-task hook API. Also, why not always dispatch micro-tasks this way? Why implement a hybrid approach at all? One idea is to just move the queue of micro-tasks to the embedder, to the definition of WebThread, so you can do: WebKitPlatformSupport::currentThread()->post{Micro}Task(task); I'm not quite sure how to name this method. I think postMicroTask is probably not the best option since that name isn't very descriptive. It is just jargon. Other ideas: postHighPriorityTask - tells you that these run before tasks produced by postTask, but it doesn't indicate that it runs before everything else too. postContinuationOfCurrentTask - long winded, but draws a connection to the current task, which seems helpful. appendToCurrentTask - a variation of the above. maybe "post" is better reserved for normal queuing? hmm, not sure. At any rate, the behavior of the above methods would be to simply append to a FIFO queue that will be drained from TaskObserver::DidProcessTask on the Chromium side. I can also imagine something like runEndOfTaskWork() working too. You could invent a class name to contain that method or perhaps it could just go in WebKit.h. 493993 2 adamk 2011-11-01 10:24:59 -0700 (In reply to comment #1) > I'd prefer a more generalized micro-task hook API. Also, why not always dispatch micro-tasks this way? Why implement a hybrid approach at all? There are several reasons. For one example, consider event-handling: when an event fires, multiple listeners may be called during the same task, so those that run after another listener has modified the DOM would get a chance to see it in an inconsistent state. Running at the end of microtask means that each event listener will have its DOM mutations delivered to MutationObservers before the next one runs. > > One idea is to just move the queue of micro-tasks to the embedder, to the definition of WebThread, so you can do: > > WebKitPlatformSupport::currentThread()->post{Micro}Task(task); > > I'm not quite sure how to name this method. I think postMicroTask is probably not the best option since that name isn't very descriptive. It is just jargon. Other ideas: > > postHighPriorityTask - tells you that these run before tasks produced by postTask, but it doesn't indicate that it runs before everything else too. > > postContinuationOfCurrentTask - long winded, but draws a connection to the current task, which seems helpful. > > appendToCurrentTask - a variation of the above. maybe "post" is better reserved for normal queuing? hmm, not sure. > > At any rate, the behavior of the above methods would be to simply append to a FIFO queue that will be drained from TaskObserver::DidProcessTask on the Chromium side. I think I like this approach, as it reduces to zero the cost of handling the (quite common) case where no DOM mutations occur during a Task. I'll look into this... > > I can also imagine something like runEndOfTaskWork() working too. You could invent a class name to contain that method or perhaps it could just go in WebKit.h. 504115 3 adamk 2011-11-16 12:07:21 -0800 (In reply to comment #2) > I think I like this approach, as it reduces to zero the cost of handling the (quite common) case where no DOM mutations occur during a Task. I'll look into this... Having looked into it, it's not clear that this is viable (especially considering that it won't be able to be generalized for microtasks as well as tasks), so I'm going to move ahead with runEndOfTaskWork() for now. 504183 4 115432 adamk 2011-11-16 13:19:17 -0800 Created attachment 115432 Patch 504187 5 webkit.review.bot 2011-11-16 13:20:32 -0800 Please wait for approval from fishd@chromium.org before submitting because this patch contains changes to the Chromium public API. 504243 6 fishd 2011-11-16 14:17:31 -0800 (In reply to comment #3) > (In reply to comment #2) > > I think I like this approach, as it reduces to zero the cost of handling the (quite common) case where no DOM mutations occur during a Task. I'll look into this... > > Having looked into it, it's not clear that this is viable (especially considering that it won't be able to be generalized for microtasks as well as tasks), so I'm going to move ahead with runEndOfTaskWork() for now. Can you describe the problem further? It seems like this is just about maintaining a queue of tasks to run after the current task completes. Maybe it actually needs to be a stack of queues in order to handle the case of further microtasks generated during the processing of a microtask. 504245 7 fishd 2011-11-16 14:20:36 -0800 (In reply to comment #6) > (In reply to comment #3) > > (In reply to comment #2) > > > I think I like this approach, as it reduces to zero the cost of handling the (quite common) case where no DOM mutations occur during a Task. I'll look into this... > > > > Having looked into it, it's not clear that this is viable (especially considering that it won't be able to be generalized for microtasks as well as tasks), so I'm going to move ahead with runEndOfTaskWork() for now. > > Can you describe the problem further? It seems like this is just about maintaining a queue of tasks to run after the current task completes. Maybe it actually needs to be a stack of queues in order to handle the case of further microtasks generated during the processing of a microtask. Or, if you wanted the queue to live in WebKit, then you could just make WebThread have a setEndOfTaskWork(Task*), and then say that there can only be one per task. That seems a bit less clean to me, however, it is basically equivalent to WebKit::runEndOfTaskWork. Have you thought about how micro-tasks should work on webworker threads? Maybe we don't need them there :) 504273 8 rafaelw 2011-11-16 14:43:07 -0800 Sorry. To clarify: Backing up a second here. I think there are three potentially orthogonal issues: 1) The end-of-microtask timing really means two things: a) At the end of the outer-most script invocation b) At the end of the task Where (b) is kind of a catch all in case work is scheduled outside of a script invocation 2) When we find a second client of end-of-task work, we'll likely want to generalize deliverAllMutations() to be runMicroTasks(), of which MutationObservers and the new thing are clients. 3) At that point, the question arises: should WebCore own the microTask queue, or should the embedder. Darin, it sounds to me like you're anticipating (2) and see value in (3) being the embedder. Is this a fair summary of the issues? If so, can you help me (us) understand your thinking. 504302 9 fishd 2011-11-16 15:05:05 -0800 > Darin, it sounds to me like you're anticipating (2) and see value in (3) being the embedder. > > Is this a fair summary of the issues? Yes, bingo! > If so, can you help me (us) understand your thinking. I think there are a number of other mutation or side-effect events generated from actions in WebCore that really should be processed using micro-tasks. Good examples are resize and scroll event handlers. We just made those fully asynchronous, but as a result we made them less useful. They were made asynchronous to avoid re-entrancy problems. I can readily imagine further use cases in the future for micro-tasks. It is a nice idea! 504307 10 adamk 2011-11-16 15:16:45 -0800 (In reply to comment #9) > > Darin, it sounds to me like you're anticipating (2) and see value in (3) being the embedder. > > > > Is this a fair summary of the issues? > > Yes, bingo! > > > > If so, can you help me (us) understand your thinking. > > I think there are a number of other mutation or side-effect events generated from actions in WebCore that really should be processed using micro-tasks. Good examples are resize and scroll event handlers. We just made those fully asynchronous, but as a result we made them less useful. They were made asynchronous to avoid re-entrancy problems. I can readily imagine further use cases in the future for micro-tasks. It is a nice idea! I think we're all agreed that this new timing will be useful. The question in play is where that queue of things-to-do-at-the-end-of-microtask should live. Right now, it lives in WebCore (managed by WebKitMutationObserver), and all the work is run when we leave the outermost script invocation (in V8Proxy::didLeaveScriptContext for ports that use V8). There's no reason we couldn't generalize that code while leaving it inside WebCore. I.e., we could add WebCore::postEndOfMicroTaskWork() (which would be called by the mutation observation mechanism) and WebCore::runEndOfMicroTaskWork() (which would be called by both didLeaveScriptContext and WebKit::runEndOfTaskWork()). If we were to move the queue out of WebCore, we'd still need some way for V8Proxy::didLeaveScriptContext to tell the embedder when a microtask ends, so it could do its work. And the benefit of having the queue owned by the embedder is unclear to us; did you have something in mind? If your concern is simply that WebCore's interface to this end-of-microtask timing should be generalized, that's fine, but it's orthogonal to the question of how the end-of-_task_ work is triggered by the embedder (which is what this patch is trying to address). Sorry this is tricky to discuss via email, the distinction between _task_ and _microtask_ is subtle, and the similarity of their names isn't helping. 504313 11 fishd 2011-11-16 15:23:15 -0800 OK, I think I have a better understanding now. I can see why having the queue live in WebCore would be simpler. I don't have a good reason for putting the queue outside of WebCore. I think that there is a fundamental primitive of the MessageLoop that we want to expose, which enables us to schedule work to follow the current task. That seems like a slightly better primitive to expose. Maybe this just amounts to adding a TaskObserver to WebThread (mirroring the one on Chromium's MessageLoop). 504335 12 adamk 2011-11-16 15:39:32 -0800 (In reply to comment #11) > OK, I think I have a better understanding now. I can see why having the queue live in WebCore would be simpler. I don't have a good reason for putting the queue outside of WebCore. > > I think that there is a fundamental primitive of the MessageLoop that we want to expose, which enables us to schedule work to follow the current task. That seems like a slightly better primitive to expose. Maybe this just amounts to adding a TaskObserver to WebThread (mirroring the one on Chromium's MessageLoop). That sounds good to me, I'll see about implementing either WebThread::postEndOfTaskWork or WebThread::addTaskObserver (I think the latter is likely to do the best job of letting the WebCore logic fully explain what's going on). 504612 13 fishd 2011-11-16 23:57:49 -0800 (In reply to comment #12) > (In reply to comment #11) > > OK, I think I have a better understanding now. I can see why having the queue live in WebCore would be simpler. I don't have a good reason for putting the queue outside of WebCore. > > > > I think that there is a fundamental primitive of the MessageLoop that we want to expose, which enables us to schedule work to follow the current task. That seems like a slightly better primitive to expose. Maybe this just amounts to adding a TaskObserver to WebThread (mirroring the one on Chromium's MessageLoop). > > That sounds good to me, I'll see about implementing either WebThread::postEndOfTaskWork or WebThread::addTaskObserver (I think the latter is likely to do the best job of letting the WebCore logic fully explain what's going on). Agreed. I'm anticipating a patch that introduces addTaskObserver :-) 504888 14 adamk 2011-11-17 08:34:12 -0800 (In reply to comment #13) > (In reply to comment #12) > > (In reply to comment #11) > > > OK, I think I have a better understanding now. I can see why having the queue live in WebCore would be simpler. I don't have a good reason for putting the queue outside of WebCore. > > > > > > I think that there is a fundamental primitive of the MessageLoop that we want to expose, which enables us to schedule work to follow the current task. That seems like a slightly better primitive to expose. Maybe this just amounts to adding a TaskObserver to WebThread (mirroring the one on Chromium's MessageLoop). > > > > That sounds good to me, I'll see about implementing either WebThread::postEndOfTaskWork or WebThread::addTaskObserver (I think the latter is likely to do the best job of letting the WebCore logic fully explain what's going on). > > Agreed. I'm anticipating a patch that introduces addTaskObserver :-) So I've put together the addTaskObserver patch, but ran into a snag in Chromium: WebThreadImplForMessageLoop only has a MessageLoopProxy, not a MessageLoop, and it's not obviously simple (or sensical) to add a pass-through for AddTaskObserver to MessageLoopProxy. How would you feel about something like WebKitPlatformSupport::addEventLoopObserver() (or addMainEventLoopObserver)? This would allow me to skirt around the above hiccup, but would only allow clients to observe tasks on the main thread (fine for my purpose, as well as any other DOM-based APIs). It's be sort of analogous to callOnMainThread. 504925 15 fishd 2011-11-17 09:45:51 -0800 (In reply to comment #14) > So I've put together the addTaskObserver patch, but ran into a snag in Chromium: WebThreadImplForMessageLoop only has a MessageLoopProxy, not a MessageLoop, and it's not obviously simple (or sensical) to add a pass-through for AddTaskObserver to MessageLoopProxy. > > How would you feel about something like WebKitPlatformSupport::addEventLoopObserver() (or addMainEventLoopObserver)? This would allow me to skirt around the above hiccup, but would only allow clients to observe tasks on the main thread (fine for my purpose, as well as any other DOM-based APIs). It's be sort of analogous to callOnMainThread. Well, since AddTaskObserver can only be called on the thread that owns the MessageLoop, you don't need to use MessageLoopProxy. Just use MessageLoop::current()->AddTaskObserver(). You should use MessageLoopProxy::BelongsToCurrentThread to verify that addTaskObserver is being called on the correct thread. 505098 16 115657 adamk 2011-11-17 12:25:57 -0800 Created attachment 115657 WebTaskObserver 505101 17 115657 fishd 2011-11-17 12:32:59 -0800 Comment on attachment 115657 WebTaskObserver View in context: https://bugs.webkit.org/attachment.cgi?id=115657&action=review > Source/WebKit/chromium/public/WebTaskObserver.h:43 > + virtual void willProcessTask() = 0; Do you need willProcessTask? Or, is this just for future-proofness? 505103 18 115657 adamk 2011-11-17 12:36:19 -0800 Comment on attachment 115657 WebTaskObserver View in context: https://bugs.webkit.org/attachment.cgi?id=115657&action=review >> Source/WebKit/chromium/public/WebTaskObserver.h:43 >> + virtual void willProcessTask() = 0; > > Do you need willProcessTask? Or, is this just for future-proofness? Future-proofness, happy to remove it if you'd rather keep this as minimal as possible (I'm already not matching MessageLoop::TaskObserver since I've removed the TimeTicks). 505162 19 fishd 2011-11-17 13:40:16 -0800 (In reply to comment #18) > (From update of attachment 115657 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=115657&action=review > > >> Source/WebKit/chromium/public/WebTaskObserver.h:43 > >> + virtual void willProcessTask() = 0; > > > > Do you need willProcessTask? Or, is this just for future-proofness? > > Future-proofness, happy to remove it if you'd rather keep this as minimal as possible (I'm already not matching MessageLoop::TaskObserver since I've removed the TimeTicks). I'd probably remove it since we don't have a need for it. Also, it seems you decided not to extend WebThread. I'm curious about that decision.. 505171 20 115657 adamk 2011-11-17 13:50:15 -0800 Comment on attachment 115657 WebTaskObserver View in context: https://bugs.webkit.org/attachment.cgi?id=115657&action=review >>>> Source/WebKit/chromium/public/WebTaskObserver.h:43 >>>> + virtual void willProcessTask() = 0; >>> >>> Do you need willProcessTask? Or, is this just for future-proofness? >> >> Future-proofness, happy to remove it if you'd rather keep this as minimal as possible (I'm already not matching MessageLoop::TaskObserver since I've removed the TimeTicks). > > I'd probably remove it since we don't have a need for it. Also, it seems you decided not to extend WebThread. I'm curious about that decision.. I guess my previous comment about MessageLoopProxy was unclear: by extending WebThread, I'm assuming you wanted something like the following to work: webKitPlatformSupport->currentThread()->addTaskObserver(observer); But currentThread() returns a WebThreadImplForMessageLoop, which wraps a MessageLoopProxy, and as previously-mentioned doesn't have an AddTaskObserver method (and likely shouldn't). For my purposes, I'd be perfectly happy if the WebThread returned by currentThread() wasn't persistent, but the other user, CCThreadImpl, holds onto a reference, and for that use case it seems safer to have a MessageLoopProxy under the covers. If you had a different API in mind than the code above, please explain. 505431 21 fishd 2011-11-17 19:36:35 -0800 Yes, I understood :-) This: webKitPlatformSupport->currentThread()->addTaskObserver(observer); Can be implemented like this: DCHECK(message_loop_proxy_->BelongsToCurrentThread()); MessageLoop::current()->AddTaskObserver(new TaskObserverAdaptor(observer)); 505787 22 adamk 2011-11-18 08:00:53 -0800 (In reply to comment #21) > Yes, I understood :-) > > This: > > webKitPlatformSupport->currentThread()->addTaskObserver(observer); > > Can be implemented like this: > > DCHECK(message_loop_proxy_->BelongsToCurrentThread()); > MessageLoop::current()->AddTaskObserver(new TaskObserverAdaptor(observer)); Ah, I see...that seems a bit weird to me (since it's only guarded by a DCHECK), but it does quite clearly mirror the Chromium interface, and thus retains the mapping MessageLoop <-> WebThread. Not sure why I was being dense, I guess if I was designing MessageLoop::AddTaskObserver I would've made it a static that only operates on the current loop :) 505867 23 fishd 2011-11-18 09:47:41 -0800 (In reply to comment #22) > (In reply to comment #21) > > Yes, I understood :-) > > > > This: > > > > webKitPlatformSupport->currentThread()->addTaskObserver(observer); > > > > Can be implemented like this: > > > > DCHECK(message_loop_proxy_->BelongsToCurrentThread()); > > MessageLoop::current()->AddTaskObserver(new TaskObserverAdaptor(observer)); > > Ah, I see...that seems a bit weird to me (since it's only guarded by a DCHECK), but it does quite clearly mirror the Chromium interface, and thus retains the mapping MessageLoop <-> WebThread. Not sure why I was being dense, I guess if I was designing MessageLoop::AddTaskObserver I would've made it a static that only operates on the current loop :) ^^^ good point! it probably would be better as a static. you could change that DCHECK to a CHECK by the way. 510154 24 116815 adamk 2011-11-28 14:02:10 -0800 Created attachment 116815 Moved to WebThread 511051 25 117032 adamk 2011-11-29 13:22:42 -0800 Created attachment 117032 Patch for landing 511057 26 117034 adamk 2011-11-29 13:26:50 -0800 Created attachment 117034 Patch for landing 511072 27 adamk 2011-11-29 13:34:30 -0800 Committed r101418: <http://trac.webkit.org/changeset/101418> 511174 28 adamk 2011-11-29 16:01:54 -0800 (In reply to comment #27) > Committed r101418: <http://trac.webkit.org/changeset/101418> This causes Chromium renderers to fail to start, due to webKitPlatformSupport->currentThread() returning NULL. If I can't figure this out quickly I'll rollout (https://bugs.webkit.org/show_bug.cgi?id=73372) 511188 29 adamk 2011-11-29 16:18:48 -0800 (In reply to comment #28) > (In reply to comment #27) > > Committed r101418: <http://trac.webkit.org/changeset/101418> > > This causes Chromium renderers to fail to start, due to webKitPlatformSupport->currentThread() returning NULL. If I can't figure this out quickly I'll rollout (https://bugs.webkit.org/show_bug.cgi?id=73372) Okay, I've found the problem. It has to do with Chromium/Linux's SandboxIPCProcess (http://code.google.com/p/chromium/wiki/LinuxSandboxIPC), which calls WebKit::initialize() without providing a MessageLoop. Two possible fixes include: - Checking to see whether webKitPlatformSupport->currentThread() is non-null before operating on it. - Calling WebKit::initializeWithoutV8() in the sandbox process, and thus avoiding our code. The latter seems to work, but I'm not clear on exactly what the process needs from WebKit. The former more obviously works, but feels weird (why would currentThread() be null?). Suggestions appreciated. 511197 30 adamk 2011-11-29 16:26:53 -0800 +agl, who may be able to answer what sort of WebKit initialization is required by the SandboxIPCProcess. 511231 31 adamk 2011-11-29 17:06:19 -0800 +levin, who added the WebKit::initialize() call in http://crrev.com/95533. It looks like this call to initialize() is unnecessary for proper operation. Perhaps it can just be removed? Looking through WebKit commit logs, I don't see the change Dave refers to when he says "Starting DumpRenderTree will assert without this after I land a change in WebKIt." [sic]. 512173 32 117283 adamk 2011-11-30 15:15:55 -0800 Created attachment 117283 For re-landing 513960 33 117658 adamk 2011-12-02 11:19:09 -0800 Created attachment 117658 Patch for landing 513979 34 adamk 2011-12-02 11:39:13 -0800 Committed r101842: <http://trac.webkit.org/changeset/101842> 115432 2011-11-16 13:19:17 -0800 2011-11-17 12:25:54 -0800 Patch bug-71242-20111116131916.patch text/plain 2471 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwNDc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDk4MzAwNDU4OWFiODUxYTAyNTEyZTJjYjBjZTQzNjE0ZTg4YzZhOWEuLmExNDI2ZDI4NGE0M2Ew ODQwNGFlY2ExMTVmM2UyMDg1NTkzZjZkMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTcgQEAKKzIwMTEtMTEtMTYgIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCBXZWJL aXQ6OnJ1bkVuZE9mVGFza1dvcmsoKSB0byB0aGUgQ2hyb21pdW0gQVBJIHdpdGggYW4KKyAgICAg ICAgaW1wbGVtZW50YXRpb24gdGhhdCBkZWxpdmVycyBtdXRhdGlvbnMgdG8gTXV0YXRpb25PYnNl cnZlcnMuCisKKyAgICAgICAgKiBwdWJsaWMvV2ViS2l0Lmg6CisgICAgICAgICogc3JjL1dlYktp dC5jcHA6CisgICAgICAgIChXZWJLaXQ6OnJ1bkVuZE9mVGFza1dvcmspOgorCiAyMDExLTExLTE2 ICBBbGV4YW5kcmUgRWxpYXMgIDxhZWxpYXNAZ29vZ2xlLmNvbT4KIAogICAgICAgICBbY2hyb21p dW1dIEFkZCBtaW5pbXVtL21heGltdW1QYWdlU2NhbGVGYWN0b3IgQVBJIGFuZCBjbGFtcCBmaXhl cwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViS2l0LmggYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJLaXQuaAppbmRleCAzMTg2YzAzMWRmM2Iw NTk0YWE1Y2JkOTNlOWIxOTI3MGEzM2MzMjUyLi5mMGJjMDkwYmY1OWFlYzViMWVmOTkwMGNhNDZi ZWYwOTc5YWVmYzMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJLaXQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJLaXQuaApAQCAt NzEsNiArNzEsMTEgQEAgV0VCS0lUX0VYUE9SVCB2b2lkIGVuYWJsZUxvZ0NoYW5uZWwoY29uc3Qg Y2hhciopOwogLy8gY29udGFpbmluZyBwbHVnaW5zIHdpbGwgYmUgcmVsb2FkZWQgYWZ0ZXIgcmVm cmVzaGluZyB0aGUgcGx1Z2luIGxpc3QuCiBXRUJLSVRfRVhQT1JUIHZvaWQgcmVzZXRQbHVnaW5D YWNoZShib29sIHJlbG9hZFBhZ2VzKTsKIAorLy8gU2hvdWxkIGJlIGNhbGxlZCBhZnRlciBlYWNo IHRhc2sgdGhlIGVtYmVkZGVyIHByb2Nlc3NlcyBvbiB0aGUgZXZlbnQgbG9vcAorLy8gdG8gdGFr ZSBjYXJlIG9mIHJ1bm5pbmcgYW55IHBlbmRpbmcgd29yayB0aGF0IG11c3QgYmUgZG9uZSBhdCB0 aGlzIHRpbWUuCisvLyBDdXJyZW50bHkgdXNlZCBmb3IgZGVsaXZlcmluZyBNdXRhdGlvblJlY29y ZHMgdG8gTXV0YXRpb25PYnNlcnZlcnMuCitXRUJLSVRfRVhQT1JUIHZvaWQgcnVuRW5kT2ZUYXNr V29yaygpOworCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJLaXQuY3BwIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViS2l0LmNwcAppbmRleCA3YmNkOWNmMjM5YTUxY2Q1MmI0Mjk3ZjVlZGMyMDA4 NzQ5YTA2ZTFmLi5jZjIxY2Q4YjI3OGQyOTRkNDI5N2Y1YTE3MzFjMzRjYjc2YmYzODRkIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJLaXQuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYktpdC5jcHAKQEAgLTM5LDYgKzM5LDcgQEAKICNpbmNs dWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlRleHRFbmNvZGluZy5oIgogI2luY2x1ZGUgIlY4 QmluZGluZy5oIgorI2luY2x1ZGUgIldlYktpdE11dGF0aW9uT2JzZXJ2ZXIuaCIKICNpbmNsdWRl ICJXZWJLaXRQbGF0Zm9ybVN1cHBvcnQuaCIKICNpbmNsdWRlICJXZWJNZWRpYVBsYXllckNsaWVu dEltcGwuaCIKICNpbmNsdWRlICJXZWJTb2NrZXQuaCIKQEAgLTEzNyw0ICsxMzgsMTEgQEAgdm9p ZCByZXNldFBsdWdpbkNhY2hlKGJvb2wgcmVsb2FkUGFnZXMpCiAgICAgV2ViQ29yZTo6UGFnZTo6 cmVmcmVzaFBsdWdpbnMocmVsb2FkUGFnZXMpOwogfQogCit2b2lkIHJ1bkVuZE9mVGFza1dvcmso KQoreworI2lmIEVOQUJMRShNVVRBVElPTl9PQlNFUlZFUlMpCisgICAgV2ViQ29yZTo6V2ViS2l0 TXV0YXRpb25PYnNlcnZlcjo6ZGVsaXZlckFsbE11dGF0aW9ucygpOworI2VuZGlmCit9CisKIH0g Ly8gbmFtZXNwYWNlIFdlYktpdAo= 115657 2011-11-17 12:25:57 -0800 2011-11-28 14:02:06 -0800 WebTaskObserver bug-71242-20111117122556.patch text/plain 7420 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAwNDc5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDk4MzAwNDU4OWFiODUxYTAyNTEyZTJjYjBjZTQzNjE0ZTg4YzZhOWEuLjU3NTY5ZTlmZmJiNzIx ZDQ0NTc5Yjc4YTM0MjlhYjBlYWFhNjRhZWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjggQEAKKzIwMTEtMTEtMTcgIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYWRkVGFz a09ic2VydmVyIGFuZCByZW1vdmVUYXNrT2JzZXJ2ZXIgdG8gV2ViS2l0UGxhdGZvcm1TdXBwb3J0 LAorICAgICAgICBhbG9uZyB3aXRoIGEgbmV3IFdlYlRhc2tPYnNlcnZlciBpbnRlcmZhY2UuCisK KyAgICAgICAgRm9yIG11dGF0aW9uIG9ic2VydmVycywgYWRkIGEgV2ViVGFza09ic2VydmVyIHRv IHRoZSBtYWluIHRocmVhZAorICAgICAgICB0byBkZWxpdmVyIG11dGF0aW9ucyBhZnRlciBlYWNo IHRhc2sgcnVucy4KKworICAgICAgICBUaGUgQ2hyb21pdW0gc2lkZSBvZiB0aGlzIHBhdGNoIGlz IGh0dHA6Ly9jb2RlcmV2aWV3LmNocm9taXVtLm9yZy84NTg2MDM4LworCisgICAgICAgICogV2Vi S2l0Lmd5cDoKKyAgICAgICAgKiBwdWJsaWMvV2ViS2l0UGxhdGZvcm1TdXBwb3J0Lmg6CisgICAg ICAgIChXZWJLaXQ6OldlYktpdFBsYXRmb3JtU3VwcG9ydDo6YWRkVGFza09ic2VydmVyKToKKyAg ICAgICAgKFdlYktpdDo6V2ViS2l0UGxhdGZvcm1TdXBwb3J0OjpyZW1vdmVUYXNrT2JzZXJ2ZXIp OgorICAgICAgICAqIHB1YmxpYy9XZWJUYXNrT2JzZXJ2ZXIuaDogQWRkZWQuCisgICAgICAgIChX ZWJLaXQ6OldlYlRhc2tPYnNlcnZlcjo6fldlYlRhc2tPYnNlcnZlcik6CisgICAgICAgICogc3Jj L1dlYktpdC5jcHA6CisgICAgICAgIChXZWJLaXQ6OmluaXRpYWxpemUpOgorICAgICAgICAoV2Vi S2l0OjpzaHV0ZG93bik6CisKIDIwMTEtMTEtMTYgIEFsZXhhbmRyZSBFbGlhcyAgPGFlbGlhc0Bn b29nbGUuY29tPgogCiAgICAgICAgIFtjaHJvbWl1bV0gQWRkIG1pbmltdW0vbWF4aW11bVBhZ2VT Y2FsZUZhY3RvciBBUEkgYW5kIGNsYW1wIGZpeGVzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL1dlYktpdC5neXAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAK aW5kZXggYmE4NTRlYWJjZDZhZjg3NDViNzFhYWI5YzE3NjUyM2MxMGU5OTI0OS4uYmIyMDMwMmVh NTNlNTIxY2RhNTliYzRlY2I3ZTIyZmNlYjFhMGJlOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0 Lmd5cApAQCAtMzA1LDYgKzMwNSw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJTdG9y YWdlUXVvdGFUeXBlLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViU3RvcmFnZU5hbWVz cGFjZS5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlN0cmluZy5oJywKKyAgICAgICAg ICAgICAgICAncHVibGljL1dlYlRhc2tPYnNlcnZlci5oJywKICAgICAgICAgICAgICAgICAncHVi bGljL1dlYlRleHRBZmZpbml0eS5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlRleHRD YXNlU2Vuc2l0aXZpdHkuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJUZXh0Q2hlY2tp bmdSZXN1bHQuaCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJLaXRQbGF0Zm9ybVN1cHBvcnQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YktpdFBsYXRmb3JtU3VwcG9ydC5oCmluZGV4IGE4NzlhYmQ3M2ZkNGJiZDVlMjk5NDdhYmE5OTM4 MWQwMDUwZGI2NWEuLmFmNzVkMmJmNGJlNjMyMDFlODA1YzhjNjQwZTEzMDIzZDlmMDNlMjIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYktpdFBsYXRmb3JtU3Vw cG9ydC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYktpdFBsYXRmb3Jt U3VwcG9ydC5oCkBAIC02OSw2ICs2OSw3IEBAIGNsYXNzIFdlYlNhbmRib3hTdXBwb3J0OwogY2xh c3MgV2ViU2hhcmVkV29ya2VyUmVwb3NpdG9yeTsKIGNsYXNzIFdlYlNvY2tldFN0cmVhbUhhbmRs ZTsKIGNsYXNzIFdlYlN0b3JhZ2VOYW1lc3BhY2U7CitjbGFzcyBXZWJUYXNrT2JzZXJ2ZXI7CiBj bGFzcyBXZWJUaGVtZUVuZ2luZTsKIGNsYXNzIFdlYlRocmVhZDsKIGNsYXNzIFdlYlVSTExvYWRl cjsKQEAgLTE5OCw2ICsxOTksMTMgQEAgcHVibGljOgogICAgIC8vIGVtYmVkZGVyLgogICAgIHZp cnR1YWwgV2ViVGhyZWFkKiBjdXJyZW50VGhyZWFkKCkgeyByZXR1cm4gMDsgfQogCisgICAgLy8g QWRkcyBhIHRhc2sgb2JzZXJ2ZXIgdG8gdGhlIGN1cnJlbnQgdGhyZWFkLiBUaGUgY2FsbGVyIHJl dGFpbnMgb3duZXJzaGlwCisgICAgLy8gb2YgdGhlIG9ic2VydmVyLgorICAgIHZpcnR1YWwgdm9p ZCBhZGRUYXNrT2JzZXJ2ZXIoV2ViVGFza09ic2VydmVyKikgeyB9CisKKyAgICAvLyBSZW1vdmVz IGEgdGFzayBvYnNlcnZlciBmcm9tIHRoZSBjdXJyZW50IHRocmVhZC4KKyAgICB2aXJ0dWFsIHZv aWQgcmVtb3ZlVGFza09ic2VydmVyKFdlYlRhc2tPYnNlcnZlciopIHsgfQorCiAKICAgICAvLyBN ZXNzYWdlIFBvcnRzIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViVGFza09ic2VydmVyLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJUYXNr T2JzZXJ2ZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iZTQ1MzIzYjY0MjI5ZDY2MDg5YThlNGI0NjBhNjdlYjNj ZDZjYTQ1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViVGFza09ic2VydmVyLmgKQEAgLTAsMCArMSw0OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAg ICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRz CisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1 Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9y IHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICog TElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViVGFza09ic2VydmVy X2gKKyNkZWZpbmUgV2ViVGFza09ic2VydmVyX2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgor CituYW1lc3BhY2UgV2ViS2l0IHsKKworLy8gQW4gaW50ZXJmYWNlIGFsbG93aW5nIGFuIG9ic2Vy dmVyIHRvIHJ1biBiZWZvcmUgYW5kL29yIGFmdGVyIHRoZSBlbWJlZGRlcidzCisvLyBldmVudCBs b29wIHByb2Nlc3NlcyBhIHRhc2suCitjbGFzcyBXZWJUYXNrT2JzZXJ2ZXIgeworcHVibGljOgor ICAgIHZpcnR1YWwgfldlYlRhc2tPYnNlcnZlcigpIHsgfQorICAgIHZpcnR1YWwgdm9pZCB3aWxs UHJvY2Vzc1Rhc2soKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGRpZFByb2Nlc3NUYXNrKCkgPSAw OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYktpdC5jcHAKaW5kZXggN2JjZDljZjIzOWE1MWNkNTJiNDI5N2Y1ZWRjMjAwODc0 OWEwNmUxZi4uOGEzM2M4YmYxYTYzMGMzNzE4NjhhNjViNDBmYjBlYTA1ZmMyMDg4OSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcAorKysgYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJLaXQuY3BwCkBAIC0zOSw5ICszOSwxMiBAQAogI2luY2x1 ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiVGV4dEVuY29kaW5nLmgiCiAjaW5jbHVkZSAiVjhC aW5kaW5nLmgiCisjaW5jbHVkZSAiV2ViS2l0TXV0YXRpb25PYnNlcnZlci5oIgogI2luY2x1ZGUg IldlYktpdFBsYXRmb3JtU3VwcG9ydC5oIgogI2luY2x1ZGUgIldlYk1lZGlhUGxheWVyQ2xpZW50 SW1wbC5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgorI2luY2x1ZGUgIldlYlRhc2tPYnNlcnZl ci5oIgorI2luY2x1ZGUgIldlYlRocmVhZC5oIgogI2luY2x1ZGUgIldvcmtlckNvbnRleHRFeGVj dXRpb25Qcm94eS5oIgogI2luY2x1ZGUgInY4LmgiCiAKQEAgLTUyLDYgKzU1LDIzIEBACiAKIG5h bWVzcGFjZSBXZWJLaXQgewogCisjaWYgRU5BQkxFKE1VVEFUSU9OX09CU0VSVkVSUykKK25hbWVz cGFjZSB7CisKK2NsYXNzIEVuZE9mVGFza1J1bm5lciA6IHB1YmxpYyBXZWJUYXNrT2JzZXJ2ZXIg eworcHVibGljOgorICAgIHZpcnR1YWwgdm9pZCB3aWxsUHJvY2Vzc1Rhc2soKSB7IH0KKyAgICB2 aXJ0dWFsIHZvaWQgZGlkUHJvY2Vzc1Rhc2soKQorICAgIHsKKyAgICAgICAgV2ViQ29yZTo6V2Vi S2l0TXV0YXRpb25PYnNlcnZlcjo6ZGVsaXZlckFsbE11dGF0aW9ucygpOworICAgIH0KK307CisK K30gLy8gbmFtZXNwYWNlCisKK3N0YXRpYyBXZWJUYXNrT2JzZXJ2ZXIqIHNfZW5kT2ZUYXNrUnVu bmVyID0gMDsKKyNlbmRpZiAvLyBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorCiAvLyBNYWtl IHN1cmUgd2UgYXJlIG5vdCByZS1pbml0aWFsaXplZCBpbiB0aGUgc2FtZSBhZGRyZXNzIHNwYWNl LgogLy8gRG9pbmcgc28gbWF5IGNhdXNlIGhhcmQgdG8gcmVwcm9kdWNlIGNyYXNoZXMuCiBzdGF0 aWMgYm9vbCBzX3dlYktpdEluaXRpYWxpemVkID0gZmFsc2U7CkBAIC03NSw2ICs5NSwxMiBAQCB2 b2lkIGluaXRpYWxpemUoV2ViS2l0UGxhdGZvcm1TdXBwb3J0KiB3ZWJLaXRQbGF0Zm9ybVN1cHBv cnQpCiAgICAgdjg6OlY4OjpTZXRFbnRyb3B5U291cmNlKCZnZW5lcmF0ZUVudHJvcHkpOwogICAg IHY4OjpWODo6SW5pdGlhbGl6ZSgpOwogICAgIFdlYkNvcmU6OlY4QmluZGluZ1Blcklzb2xhdGVE YXRhOjplbnN1cmVJbml0aWFsaXplZCh2ODo6SXNvbGF0ZTo6R2V0Q3VycmVudCgpKTsKKworI2lm IEVOQUJMRShNVVRBVElPTl9PQlNFUlZFUlMpCisgICAgQVNTRVJUKCFzX2VuZE9mVGFza1J1bm5l cik7CisgICAgc19lbmRPZlRhc2tSdW5uZXIgPSBuZXcgRW5kT2ZUYXNrUnVubmVyOworICAgIHdl YktpdFBsYXRmb3JtU3VwcG9ydC0+YWRkVGFza09ic2VydmVyKHNfZW5kT2ZUYXNrUnVubmVyKTsK KyNlbmRpZgogfQogCiB2b2lkIGluaXRpYWxpemVXaXRob3V0VjgoV2ViS2l0UGxhdGZvcm1TdXBw b3J0KiB3ZWJLaXRQbGF0Zm9ybVN1cHBvcnQpCkBAIC0xMDcsNiArMTMzLDEzIEBAIHZvaWQgc2h1 dGRvd24oKQogewogICAgIGRlbGV0ZSBXZWJDb3JlOjpDQ1Byb3h5OjptYWluVGhyZWFkKCk7CiAg ICAgV2ViQ29yZTo6Q0NQcm94eTo6c2V0TWFpblRocmVhZCgwKTsKKyNpZiBFTkFCTEUoTVVUQVRJ T05fT0JTRVJWRVJTKQorICAgIGlmIChzX2VuZE9mVGFza1J1bm5lcikgeworICAgICAgICBzX3dl YktpdFBsYXRmb3JtU3VwcG9ydC0+cmVtb3ZlVGFza09ic2VydmVyKHNfZW5kT2ZUYXNrUnVubmVy KTsKKyAgICAgICAgZGVsZXRlIHNfZW5kT2ZUYXNrUnVubmVyOworICAgICAgICBzX2VuZE9mVGFz a1J1bm5lciA9IDA7CisgICAgfQorI2VuZGlmCiAgICAgc193ZWJLaXRQbGF0Zm9ybVN1cHBvcnQg PSAwOwogfQogCg== 116815 2011-11-28 14:02:10 -0800 2011-11-29 13:22:39 -0800 Moved to WebThread bug-71242-20111128140209.patch text/plain 4009 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxMTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDg5YjlkZDE0OWFmMDIyMmYxYzQxOGE0ZGFiMzA5NGM5M2YzZTNlMmUuLjhhODA0MjI2ZjIwMmFm M2E4ZDQ5NmUwY2Y3ZWMwNDgwOTI2Njc1ZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjQgQEAKKzIwMTEtMTEtMjggIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYWRkVGFz a09ic2VydmVyIGFuZCByZW1vdmVUYXNrT2JzZXJ2ZXIgdG8gV2ViVGhyZWFkLAorICAgICAgICBh bG9uZyB3aXRoIGEgbmV3IFdlYlRocmVhZDo6VGFza09ic2VydmVyIGludGVyZmFjZS4KKworICAg ICAgICBGb3IgbXV0YXRpb24gb2JzZXJ2ZXJzLCBhZGQgYSBUYXNrT2JzZXJ2ZXIgdG8gdGhlIG1h aW4gdGhyZWFkCisgICAgICAgIHRvIGRlbGl2ZXIgbXV0YXRpb25zIGFmdGVyIGVhY2ggdGFzayBy dW5zLgorCisgICAgICAgIFRoZSBDaHJvbWl1bSBzaWRlIG9mIHRoaXMgcGF0Y2ggaXMgaHR0cDov L2NvZGVyZXZpZXcuY2hyb21pdW0ub3JnLzg1ODYwMzgvCisKKyAgICAgICAgKiBwdWJsaWMvV2Vi VGhyZWFkLmg6CisgICAgICAgIChXZWJLaXQ6OldlYlRocmVhZDo6VGFza09ic2VydmVyOjp+VGFz a09ic2VydmVyKToKKyAgICAgICAgKiBzcmMvV2ViS2l0LmNwcDoKKyAgICAgICAgKFdlYktpdDo6 aW5pdGlhbGl6ZSk6CisgICAgICAgIChXZWJLaXQ6OnNodXRkb3duKToKKwogMjAxMS0xMS0yMyAg VG9tbXkgV2lkZW5mbHljaHQgIDx0b21teXdAZ29vZ2xlLmNvbT4KIAogICAgICAgICBbY2hyb21p dW1dIE1lZGlhU3RyZWFtIEFQSTogTWlzc2luZyBXRUJLSVRfRVhQT1JUIGluIFdlYk1lZGlhU3Ry ZWFtUmVnaXN0cnkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YlRocmVhZC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViVGhyZWFkLmgKaW5k ZXggZGIyNTU1NmY5ZmVjZTY4ZTZiZTZlZDM4ZjBkYTgyMjljMGY3ZWUyYS4uZjY0MWRiMzc0ZTEw MTg1ZDVmZDU1MTA0MzFjNzcxZTA1YWI5YzIxMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViVGhyZWFkLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViVGhyZWFkLmgKQEAgLTQzLDggKzQzLDE2IEBAIHB1YmxpYzoKICAgICAgICAgdmly dHVhbCB2b2lkIHJ1bigpID0gMDsKICAgICB9OwogCisgICAgY2xhc3MgVGFza09ic2VydmVyIHsK KyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwgflRhc2tPYnNlcnZlcigpIHsgfQorICAgICAg ICB2aXJ0dWFsIHZvaWQgZGlkUHJvY2Vzc1Rhc2soKSA9IDA7CisgICAgfTsKKwogICAgIHZpcnR1 YWwgdm9pZCBwb3N0VGFzayhUYXNrKikgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBwb3N0RGVsYXll ZFRhc2soVGFzayosIGxvbmcgbG9uZyBkZWxheU1zKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGFk ZFRhc2tPYnNlcnZlcihUYXNrT2JzZXJ2ZXIqKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIHJlbW92 ZVRhc2tPYnNlcnZlcihUYXNrT2JzZXJ2ZXIqKSA9IDA7CiAKICAgICB2aXJ0dWFsIH5XZWJUaHJl YWQoKSB7IH0KIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJL aXQuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcAppbmRleCA3YmNk OWNmMjM5YTUxY2Q1MmI0Mjk3ZjVlZGMyMDA4NzQ5YTA2ZTFmLi4wZDZkOTM1YTQwY2MxZDI3MmI3 NzVhZTQ1MTY2ZTdmNDk2OTBkZDZkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJLaXQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYktpdC5j cHAKQEAgLTM5LDkgKzM5LDExIEBACiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJU ZXh0RW5jb2RpbmcuaCIKICNpbmNsdWRlICJWOEJpbmRpbmcuaCIKKyNpbmNsdWRlICJXZWJLaXRN dXRhdGlvbk9ic2VydmVyLmgiCiAjaW5jbHVkZSAiV2ViS2l0UGxhdGZvcm1TdXBwb3J0LmgiCiAj aW5jbHVkZSAiV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgiCiAjaW5jbHVkZSAiV2ViU29ja2V0 LmgiCisjaW5jbHVkZSAiV2ViVGhyZWFkLmgiCiAjaW5jbHVkZSAiV29ya2VyQ29udGV4dEV4ZWN1 dGlvblByb3h5LmgiCiAjaW5jbHVkZSAidjguaCIKIApAQCAtNTIsNiArNTQsMjIgQEAKIAogbmFt ZXNwYWNlIFdlYktpdCB7CiAKKyNpZiBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorbmFtZXNw YWNlIHsKKworY2xhc3MgRW5kT2ZUYXNrUnVubmVyIDogcHVibGljIFdlYlRocmVhZDo6VGFza09i c2VydmVyIHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgZGlkUHJvY2Vzc1Rhc2soKQorICAg IHsKKyAgICAgICAgV2ViQ29yZTo6V2ViS2l0TXV0YXRpb25PYnNlcnZlcjo6ZGVsaXZlckFsbE11 dGF0aW9ucygpOworICAgIH0KK307CisKK30gLy8gbmFtZXNwYWNlCisKK3N0YXRpYyBXZWJUaHJl YWQ6OlRhc2tPYnNlcnZlciogc19lbmRPZlRhc2tSdW5uZXIgPSAwOworI2VuZGlmIC8vIEVOQUJM RShNVVRBVElPTl9PQlNFUlZFUlMpCisKIC8vIE1ha2Ugc3VyZSB3ZSBhcmUgbm90IHJlLWluaXRp YWxpemVkIGluIHRoZSBzYW1lIGFkZHJlc3Mgc3BhY2UuCiAvLyBEb2luZyBzbyBtYXkgY2F1c2Ug aGFyZCB0byByZXByb2R1Y2UgY3Jhc2hlcy4KIHN0YXRpYyBib29sIHNfd2ViS2l0SW5pdGlhbGl6 ZWQgPSBmYWxzZTsKQEAgLTc1LDYgKzkzLDEyIEBAIHZvaWQgaW5pdGlhbGl6ZShXZWJLaXRQbGF0 Zm9ybVN1cHBvcnQqIHdlYktpdFBsYXRmb3JtU3VwcG9ydCkKICAgICB2ODo6Vjg6OlNldEVudHJv cHlTb3VyY2UoJmdlbmVyYXRlRW50cm9weSk7CiAgICAgdjg6OlY4OjpJbml0aWFsaXplKCk7CiAg ICAgV2ViQ29yZTo6VjhCaW5kaW5nUGVySXNvbGF0ZURhdGE6OmVuc3VyZUluaXRpYWxpemVkKHY4 OjpJc29sYXRlOjpHZXRDdXJyZW50KCkpOworCisjaWYgRU5BQkxFKE1VVEFUSU9OX09CU0VSVkVS UykKKyAgICBBU1NFUlQoIXNfZW5kT2ZUYXNrUnVubmVyKTsKKyAgICBzX2VuZE9mVGFza1J1bm5l ciA9IG5ldyBFbmRPZlRhc2tSdW5uZXI7CisgICAgd2ViS2l0UGxhdGZvcm1TdXBwb3J0LT5jdXJy ZW50VGhyZWFkKCktPmFkZFRhc2tPYnNlcnZlcihzX2VuZE9mVGFza1J1bm5lcik7CisjZW5kaWYK IH0KIAogdm9pZCBpbml0aWFsaXplV2l0aG91dFY4KFdlYktpdFBsYXRmb3JtU3VwcG9ydCogd2Vi S2l0UGxhdGZvcm1TdXBwb3J0KQpAQCAtMTA3LDYgKzEzMSwxMyBAQCB2b2lkIHNodXRkb3duKCkK IHsKICAgICBkZWxldGUgV2ViQ29yZTo6Q0NQcm94eTo6bWFpblRocmVhZCgpOwogICAgIFdlYkNv cmU6OkNDUHJveHk6OnNldE1haW5UaHJlYWQoMCk7CisjaWYgRU5BQkxFKE1VVEFUSU9OX09CU0VS VkVSUykKKyAgICBpZiAoc19lbmRPZlRhc2tSdW5uZXIpIHsKKyAgICAgICAgc193ZWJLaXRQbGF0 Zm9ybVN1cHBvcnQtPmN1cnJlbnRUaHJlYWQoKS0+cmVtb3ZlVGFza09ic2VydmVyKHNfZW5kT2ZU YXNrUnVubmVyKTsKKyAgICAgICAgZGVsZXRlIHNfZW5kT2ZUYXNrUnVubmVyOworICAgICAgICBz X2VuZE9mVGFza1J1bm5lciA9IDA7CisgICAgfQorI2VuZGlmCiAgICAgc193ZWJLaXRQbGF0Zm9y bVN1cHBvcnQgPSAwOwogfQogCg== 117032 2011-11-29 13:22:42 -0800 2011-11-29 13:26:47 -0800 Patch for landing bug-71242-20111129132241.patch text/plain 4005 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxMTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDg5YjlkZDE0OWFmMDIyMmYxYzQxOGE0ZGFiMzA5NGM5M2YzZTNlMmUuLmUxMGZjN2I1YmE0NThm MjA3ZjJhMWNmMWE0NzFlMjEwNGI3Mzg3ODUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjQgQEAKKzIwMTEtMTEtMjggIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBGaXNoZXIuCisKKyAgICAgICAgQWRkIGFkZFRhc2tP YnNlcnZlciBhbmQgcmVtb3ZlVGFza09ic2VydmVyIHRvIFdlYlRocmVhZCwKKyAgICAgICAgYWxv bmcgd2l0aCBhIG5ldyBXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlciBpbnRlcmZhY2UuCisKKyAgICAg ICAgRm9yIG11dGF0aW9uIG9ic2VydmVycywgYWRkIGEgVGFza09ic2VydmVyIHRvIHRoZSBtYWlu IHRocmVhZAorICAgICAgICB0byBkZWxpdmVyIG11dGF0aW9ucyBhZnRlciBlYWNoIHRhc2sgcnVu cy4KKworICAgICAgICBUaGUgQ2hyb21pdW0gc2lkZSBvZiB0aGlzIHBhdGNoIGlzIGh0dHA6Ly9j b2RlcmV2aWV3LmNocm9taXVtLm9yZy84NTg2MDM4LworCisgICAgICAgICogcHVibGljL1dlYlRo cmVhZC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlcjo6flRhc2tP YnNlcnZlcik6CisgICAgICAgICogc3JjL1dlYktpdC5jcHA6CisgICAgICAgIChXZWJLaXQ6Omlu aXRpYWxpemUpOgorICAgICAgICAoV2ViS2l0OjpzaHV0ZG93bik6CisKIDIwMTEtMTEtMjMgIFRv bW15IFdpZGVuZmx5Y2h0ICA8dG9tbXl3QGdvb2dsZS5jb20+CiAKICAgICAgICAgW2Nocm9taXVt XSBNZWRpYVN0cmVhbSBBUEk6IE1pc3NpbmcgV0VCS0lUX0VYUE9SVCBpbiBXZWJNZWRpYVN0cmVh bVJlZ2lzdHJ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJU aHJlYWQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlRocmVhZC5oCmluZGV4 IGRiMjU1NTZmOWZlY2U2OGU2YmU2ZWQzOGYwZGE4MjI5YzBmN2VlMmEuLmE3YjM3MmZlZTM0ZDdk ZmQ5YzdjYTE2NDUxMzJmZTA0OWMwYjY4NWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYlRocmVhZC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYlRocmVhZC5oCkBAIC00Myw4ICs0MywxNiBAQCBwdWJsaWM6CiAgICAgICAgIHZpcnR1 YWwgdm9pZCBydW4oKSA9IDA7CiAgICAgfTsKIAorICAgIGNsYXNzIFRhc2tPYnNlcnZlciB7Cisg ICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIH5UYXNrT2JzZXJ2ZXIoKSB7IH0KKyAgICAgICAg dmlydHVhbCB2b2lkIGRpZFByb2Nlc3NUYXNrKCkgPSAwOworICAgIH07CisKICAgICB2aXJ0dWFs IHZvaWQgcG9zdFRhc2soVGFzayopID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgcG9zdERlbGF5ZWRU YXNrKFRhc2sqLCBsb25nIGxvbmcgZGVsYXlNcykgPSAwOworICAgIHZpcnR1YWwgdm9pZCBhZGRU YXNrT2JzZXJ2ZXIoVGFza09ic2VydmVyKikgeyB9CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZVRh c2tPYnNlcnZlcihUYXNrT2JzZXJ2ZXIqKSB7IH0KIAogICAgIHZpcnR1YWwgfldlYlRocmVhZCgp IHsgfQogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYktpdC5j cHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJLaXQuY3BwCmluZGV4IDdiY2Q5Y2Yy MzlhNTFjZDUyYjQyOTdmNWVkYzIwMDg3NDlhMDZlMWYuLjBkNmQ5MzVhNDBjYzFkMjcyYjc3NWFl NDUxNjZlN2Y0OTY5MGRkNmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYktpdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcApA QCAtMzksOSArMzksMTEgQEAKICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlRleHRF bmNvZGluZy5oIgogI2luY2x1ZGUgIlY4QmluZGluZy5oIgorI2luY2x1ZGUgIldlYktpdE11dGF0 aW9uT2JzZXJ2ZXIuaCIKICNpbmNsdWRlICJXZWJLaXRQbGF0Zm9ybVN1cHBvcnQuaCIKICNpbmNs dWRlICJXZWJNZWRpYVBsYXllckNsaWVudEltcGwuaCIKICNpbmNsdWRlICJXZWJTb2NrZXQuaCIK KyNpbmNsdWRlICJXZWJUaHJlYWQuaCIKICNpbmNsdWRlICJXb3JrZXJDb250ZXh0RXhlY3V0aW9u UHJveHkuaCIKICNpbmNsdWRlICJ2OC5oIgogCkBAIC01Miw2ICs1NCwyMiBAQAogCiBuYW1lc3Bh Y2UgV2ViS2l0IHsKIAorI2lmIEVOQUJMRShNVVRBVElPTl9PQlNFUlZFUlMpCituYW1lc3BhY2Ug eworCitjbGFzcyBFbmRPZlRhc2tSdW5uZXIgOiBwdWJsaWMgV2ViVGhyZWFkOjpUYXNrT2JzZXJ2 ZXIgeworcHVibGljOgorICAgIHZpcnR1YWwgdm9pZCBkaWRQcm9jZXNzVGFzaygpCisgICAgewor ICAgICAgICBXZWJDb3JlOjpXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVyQWxsTXV0YXRp b25zKCk7CisgICAgfQorfTsKKworfSAvLyBuYW1lc3BhY2UKKworc3RhdGljIFdlYlRocmVhZDo6 VGFza09ic2VydmVyKiBzX2VuZE9mVGFza1J1bm5lciA9IDA7CisjZW5kaWYgLy8gRU5BQkxFKE1V VEFUSU9OX09CU0VSVkVSUykKKwogLy8gTWFrZSBzdXJlIHdlIGFyZSBub3QgcmUtaW5pdGlhbGl6 ZWQgaW4gdGhlIHNhbWUgYWRkcmVzcyBzcGFjZS4KIC8vIERvaW5nIHNvIG1heSBjYXVzZSBoYXJk IHRvIHJlcHJvZHVjZSBjcmFzaGVzLgogc3RhdGljIGJvb2wgc193ZWJLaXRJbml0aWFsaXplZCA9 IGZhbHNlOwpAQCAtNzUsNiArOTMsMTIgQEAgdm9pZCBpbml0aWFsaXplKFdlYktpdFBsYXRmb3Jt U3VwcG9ydCogd2ViS2l0UGxhdGZvcm1TdXBwb3J0KQogICAgIHY4OjpWODo6U2V0RW50cm9weVNv dXJjZSgmZ2VuZXJhdGVFbnRyb3B5KTsKICAgICB2ODo6Vjg6OkluaXRpYWxpemUoKTsKICAgICBX ZWJDb3JlOjpWOEJpbmRpbmdQZXJJc29sYXRlRGF0YTo6ZW5zdXJlSW5pdGlhbGl6ZWQodjg6Oklz b2xhdGU6OkdldEN1cnJlbnQoKSk7CisKKyNpZiBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQor ICAgIEFTU0VSVCghc19lbmRPZlRhc2tSdW5uZXIpOworICAgIHNfZW5kT2ZUYXNrUnVubmVyID0g bmV3IEVuZE9mVGFza1J1bm5lcjsKKyAgICB3ZWJLaXRQbGF0Zm9ybVN1cHBvcnQtPmN1cnJlbnRU aHJlYWQoKS0+YWRkVGFza09ic2VydmVyKHNfZW5kT2ZUYXNrUnVubmVyKTsKKyNlbmRpZgogfQog CiB2b2lkIGluaXRpYWxpemVXaXRob3V0VjgoV2ViS2l0UGxhdGZvcm1TdXBwb3J0KiB3ZWJLaXRQ bGF0Zm9ybVN1cHBvcnQpCkBAIC0xMDcsNiArMTMxLDEzIEBAIHZvaWQgc2h1dGRvd24oKQogewog ICAgIGRlbGV0ZSBXZWJDb3JlOjpDQ1Byb3h5OjptYWluVGhyZWFkKCk7CiAgICAgV2ViQ29yZTo6 Q0NQcm94eTo6c2V0TWFpblRocmVhZCgwKTsKKyNpZiBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJT KQorICAgIGlmIChzX2VuZE9mVGFza1J1bm5lcikgeworICAgICAgICBzX3dlYktpdFBsYXRmb3Jt U3VwcG9ydC0+Y3VycmVudFRocmVhZCgpLT5yZW1vdmVUYXNrT2JzZXJ2ZXIoc19lbmRPZlRhc2tS dW5uZXIpOworICAgICAgICBkZWxldGUgc19lbmRPZlRhc2tSdW5uZXI7CisgICAgICAgIHNfZW5k T2ZUYXNrUnVubmVyID0gMDsKKyAgICB9CisjZW5kaWYKICAgICBzX3dlYktpdFBsYXRmb3JtU3Vw cG9ydCA9IDA7CiB9CiAK 117034 2011-11-29 13:26:50 -0800 2011-11-30 15:15:51 -0800 Patch for landing bug-71242-20111129132649.patch text/plain 4040 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxMzkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDA4OTI5YzQwZjcxYTZkNDViOTI3NTE4NTUxMmMxODZjZmMyNTBiYmEuLjlkZmNhYmVlN2ZlY2Ez ODkzMjRjMTkyODU4N2FhMTFjM2RiNTYyYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjQgQEAKKzIwMTEtMTEtMjggIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBGaXNoZXIuCisKKyAgICAgICAgQWRkIGFkZFRhc2tP YnNlcnZlciBhbmQgcmVtb3ZlVGFza09ic2VydmVyIHRvIFdlYlRocmVhZCwKKyAgICAgICAgYWxv bmcgd2l0aCBhIG5ldyBXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlciBpbnRlcmZhY2UuCisKKyAgICAg ICAgRm9yIG11dGF0aW9uIG9ic2VydmVycywgYWRkIGEgVGFza09ic2VydmVyIHRvIHRoZSBtYWlu IHRocmVhZAorICAgICAgICB0byBkZWxpdmVyIG11dGF0aW9ucyBhZnRlciBlYWNoIHRhc2sgcnVu cy4KKworICAgICAgICBUaGUgQ2hyb21pdW0gc2lkZSBvZiB0aGlzIHBhdGNoIGlzIGh0dHA6Ly9j b2RlcmV2aWV3LmNocm9taXVtLm9yZy84NTg2MDM4LworCisgICAgICAgICogcHVibGljL3BsYXRm b3JtL1dlYlRocmVhZC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJUaHJlYWQ6OlRhc2tPYnNlcnZl cjo6flRhc2tPYnNlcnZlcik6CisgICAgICAgICogc3JjL1dlYktpdC5jcHA6CisgICAgICAgIChX ZWJLaXQ6OmluaXRpYWxpemUpOgorICAgICAgICAoV2ViS2l0OjpzaHV0ZG93bik6CisKIDIwMTEt MTEtMjkgIFBhdmVsIEZlbGRtYW4gIDxwZmVsZG1hbkBnb29nbGUuY29tPgogCiAgICAgICAgIFdl YiBJbnNwZWN0b3I6IHNwbGl0IFByZWZlcmVuY2VzIGludG8gUHJlZmVyZW5jZXMgYW5kIENhcGFi aWxpdGllcy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRm b3JtL1dlYlRocmVhZC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0v V2ViVGhyZWFkLmgKaW5kZXggZGIyNTU1NmY5ZmVjZTY4ZTZiZTZlZDM4ZjBkYTgyMjljMGY3ZWUy YS4uYTdiMzcyZmVlMzRkN2RmZDljN2NhMTY0NTEzMmZlMDQ5YzBiNjg1YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViVGhyZWFkLmgKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViVGhyZWFkLmgKQEAgLTQz LDggKzQzLDE2IEBAIHB1YmxpYzoKICAgICAgICAgdmlydHVhbCB2b2lkIHJ1bigpID0gMDsKICAg ICB9OwogCisgICAgY2xhc3MgVGFza09ic2VydmVyIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZp cnR1YWwgflRhc2tPYnNlcnZlcigpIHsgfQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUHJvY2Vz c1Rhc2soKSA9IDA7CisgICAgfTsKKwogICAgIHZpcnR1YWwgdm9pZCBwb3N0VGFzayhUYXNrKikg PSAwOwogICAgIHZpcnR1YWwgdm9pZCBwb3N0RGVsYXllZFRhc2soVGFzayosIGxvbmcgbG9uZyBk ZWxheU1zKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGFkZFRhc2tPYnNlcnZlcihUYXNrT2JzZXJ2 ZXIqKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlVGFza09ic2VydmVyKFRhc2tPYnNlcnZl ciopIHsgfQogCiAgICAgdmlydHVhbCB+V2ViVGhyZWFkKCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYktpdC5jcHAKaW5kZXggN2JjZDljZjIzOWE1MWNkNTJiNDI5N2Y1ZWRjMjAw ODc0OWEwNmUxZi4uMGQ2ZDkzNWE0MGNjMWQyNzJiNzc1YWU0NTE2NmU3ZjQ5NjkwZGQ2ZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJLaXQuY3BwCkBAIC0zOSw5ICszOSwxMSBAQAogI2lu Y2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiVGV4dEVuY29kaW5nLmgiCiAjaW5jbHVkZSAi VjhCaW5kaW5nLmgiCisjaW5jbHVkZSAiV2ViS2l0TXV0YXRpb25PYnNlcnZlci5oIgogI2luY2x1 ZGUgIldlYktpdFBsYXRmb3JtU3VwcG9ydC5oIgogI2luY2x1ZGUgIldlYk1lZGlhUGxheWVyQ2xp ZW50SW1wbC5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgorI2luY2x1ZGUgIldlYlRocmVhZC5o IgogI2luY2x1ZGUgIldvcmtlckNvbnRleHRFeGVjdXRpb25Qcm94eS5oIgogI2luY2x1ZGUgInY4 LmgiCiAKQEAgLTUyLDYgKzU0LDIyIEBACiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCisjaWYgRU5B QkxFKE1VVEFUSU9OX09CU0VSVkVSUykKK25hbWVzcGFjZSB7CisKK2NsYXNzIEVuZE9mVGFza1J1 bm5lciA6IHB1YmxpYyBXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlciB7CitwdWJsaWM6CisgICAgdmly dHVhbCB2b2lkIGRpZFByb2Nlc3NUYXNrKCkKKyAgICB7CisgICAgICAgIFdlYkNvcmU6OldlYktp dE11dGF0aW9uT2JzZXJ2ZXI6OmRlbGl2ZXJBbGxNdXRhdGlvbnMoKTsKKyAgICB9Cit9OworCit9 IC8vIG5hbWVzcGFjZQorCitzdGF0aWMgV2ViVGhyZWFkOjpUYXNrT2JzZXJ2ZXIqIHNfZW5kT2ZU YXNrUnVubmVyID0gMDsKKyNlbmRpZiAvLyBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorCiAv LyBNYWtlIHN1cmUgd2UgYXJlIG5vdCByZS1pbml0aWFsaXplZCBpbiB0aGUgc2FtZSBhZGRyZXNz IHNwYWNlLgogLy8gRG9pbmcgc28gbWF5IGNhdXNlIGhhcmQgdG8gcmVwcm9kdWNlIGNyYXNoZXMu CiBzdGF0aWMgYm9vbCBzX3dlYktpdEluaXRpYWxpemVkID0gZmFsc2U7CkBAIC03NSw2ICs5Mywx MiBAQCB2b2lkIGluaXRpYWxpemUoV2ViS2l0UGxhdGZvcm1TdXBwb3J0KiB3ZWJLaXRQbGF0Zm9y bVN1cHBvcnQpCiAgICAgdjg6OlY4OjpTZXRFbnRyb3B5U291cmNlKCZnZW5lcmF0ZUVudHJvcHkp OwogICAgIHY4OjpWODo6SW5pdGlhbGl6ZSgpOwogICAgIFdlYkNvcmU6OlY4QmluZGluZ1Blcklz b2xhdGVEYXRhOjplbnN1cmVJbml0aWFsaXplZCh2ODo6SXNvbGF0ZTo6R2V0Q3VycmVudCgpKTsK KworI2lmIEVOQUJMRShNVVRBVElPTl9PQlNFUlZFUlMpCisgICAgQVNTRVJUKCFzX2VuZE9mVGFz a1J1bm5lcik7CisgICAgc19lbmRPZlRhc2tSdW5uZXIgPSBuZXcgRW5kT2ZUYXNrUnVubmVyOwor ICAgIHdlYktpdFBsYXRmb3JtU3VwcG9ydC0+Y3VycmVudFRocmVhZCgpLT5hZGRUYXNrT2JzZXJ2 ZXIoc19lbmRPZlRhc2tSdW5uZXIpOworI2VuZGlmCiB9CiAKIHZvaWQgaW5pdGlhbGl6ZVdpdGhv dXRWOChXZWJLaXRQbGF0Zm9ybVN1cHBvcnQqIHdlYktpdFBsYXRmb3JtU3VwcG9ydCkKQEAgLTEw Nyw2ICsxMzEsMTMgQEAgdm9pZCBzaHV0ZG93bigpCiB7CiAgICAgZGVsZXRlIFdlYkNvcmU6OkND UHJveHk6Om1haW5UaHJlYWQoKTsKICAgICBXZWJDb3JlOjpDQ1Byb3h5OjpzZXRNYWluVGhyZWFk KDApOworI2lmIEVOQUJMRShNVVRBVElPTl9PQlNFUlZFUlMpCisgICAgaWYgKHNfZW5kT2ZUYXNr UnVubmVyKSB7CisgICAgICAgIHNfd2ViS2l0UGxhdGZvcm1TdXBwb3J0LT5jdXJyZW50VGhyZWFk KCktPnJlbW92ZVRhc2tPYnNlcnZlcihzX2VuZE9mVGFza1J1bm5lcik7CisgICAgICAgIGRlbGV0 ZSBzX2VuZE9mVGFza1J1bm5lcjsKKyAgICAgICAgc19lbmRPZlRhc2tSdW5uZXIgPSAwOworICAg IH0KKyNlbmRpZgogICAgIHNfd2ViS2l0UGxhdGZvcm1TdXBwb3J0ID0gMDsKIH0KIAo= 117283 2011-11-30 15:15:55 -0800 2011-12-02 11:19:04 -0800 For re-landing bug-71242-20111130151554.patch text/plain 4206 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxNTU4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDdmMmQ2ZWE5ZTZmOTcxYTM3NTE1YWY2OGU1MzI3MDVjNmJmNTYzMzQuLjQwNzdlNWMxMDJlOTc1 ZjMzNjAxYmFlOTkwMTU1MjljOGY1NmU2YjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjggQEAKKzIwMTEtMTEtMzAgIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZWxhbmRpbmcs IGRlcGVuZHMgb24gaHR0cDovL2NvZGVyZXZpZXcuY2hyb21pdW0ub3JnLzg3NDgwMTUvCisgICAg ICAgIHRvIGZpeCBhIHNhbmRib3hpbmcgaXNzdWUgb24gQ2hyb21pdW0vTGludXguCisKKyAgICAg ICAgQWRkIGFkZFRhc2tPYnNlcnZlciBhbmQgcmVtb3ZlVGFza09ic2VydmVyIHRvIFdlYlRocmVh ZCwKKyAgICAgICAgYWxvbmcgd2l0aCBhIG5ldyBXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlciBpbnRl cmZhY2UuCisKKyAgICAgICAgRm9yIG11dGF0aW9uIG9ic2VydmVycywgYWRkIGEgVGFza09ic2Vy dmVyIHRvIHRoZSBtYWluIHRocmVhZAorICAgICAgICB0byBkZWxpdmVyIG11dGF0aW9ucyBhZnRl ciBlYWNoIHRhc2sgcnVucy4KKworICAgICAgICBUaGUgQ2hyb21pdW0gaW1wbGVtZW50YXRpb24g b2YgdGhlIG5ldyBXZWJUaHJlYWQgbWV0aG9kcyBpcyBpbgorICAgICAgICBodHRwOi8vY29kZXJl dmlldy5jaHJvbWl1bS5vcmcvODU4NjAzOC8uCisKKyAgICAgICAgKiBwdWJsaWMvcGxhdGZvcm0v V2ViVGhyZWFkLmg6CisgICAgICAgIChXZWJLaXQ6OldlYlRocmVhZDo6VGFza09ic2VydmVyOjp+ VGFza09ic2VydmVyKToKKyAgICAgICAgKiBzcmMvV2ViS2l0LmNwcDoKKyAgICAgICAgKFdlYktp dDo6aW5pdGlhbGl6ZSk6CisgICAgICAgIChXZWJLaXQ6OnNodXRkb3duKToKKwogMjAxMS0xMS0z MCAgRGF2aWQgTGV2aW4gIDxsZXZpbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW2Nocm9taXVt XSBNb3ZlIGRpZFVwZGF0ZUxheW91dCBmcm9tIFdlYkZyYW1lQ2xpZW50IHRvIFdlYlZpZXdDbGll bnQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9X ZWJUaHJlYWQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYlRo cmVhZC5oCmluZGV4IGRiMjU1NTZmOWZlY2U2OGU2YmU2ZWQzOGYwZGE4MjI5YzBmN2VlMmEuLmE3 YjM3MmZlZTM0ZDdkZmQ5YzdjYTE2NDUxMzJmZTA0OWMwYjY4NWIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYlRocmVhZC5oCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYlRocmVhZC5oCkBAIC00Myw4ICs0 MywxNiBAQCBwdWJsaWM6CiAgICAgICAgIHZpcnR1YWwgdm9pZCBydW4oKSA9IDA7CiAgICAgfTsK IAorICAgIGNsYXNzIFRhc2tPYnNlcnZlciB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFs IH5UYXNrT2JzZXJ2ZXIoKSB7IH0KKyAgICAgICAgdmlydHVhbCB2b2lkIGRpZFByb2Nlc3NUYXNr KCkgPSAwOworICAgIH07CisKICAgICB2aXJ0dWFsIHZvaWQgcG9zdFRhc2soVGFzayopID0gMDsK ICAgICB2aXJ0dWFsIHZvaWQgcG9zdERlbGF5ZWRUYXNrKFRhc2sqLCBsb25nIGxvbmcgZGVsYXlN cykgPSAwOworICAgIHZpcnR1YWwgdm9pZCBhZGRUYXNrT2JzZXJ2ZXIoVGFza09ic2VydmVyKikg eyB9CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZVRhc2tPYnNlcnZlcihUYXNrT2JzZXJ2ZXIqKSB7 IH0KIAogICAgIHZpcnR1YWwgfldlYlRocmVhZCgpIHsgfQogfTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYktpdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJLaXQuY3BwCmluZGV4IDdiY2Q5Y2YyMzlhNTFjZDUyYjQyOTdmNWVkYzIwMDg3NDlh MDZlMWYuLjBkNmQ5MzVhNDBjYzFkMjcyYjc3NWFlNDUxNjZlN2Y0OTY5MGRkNmQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYktpdC5jcHAKKysrIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcApAQCAtMzksOSArMzksMTEgQEAKICNpbmNsdWRl ICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlRleHRFbmNvZGluZy5oIgogI2luY2x1ZGUgIlY4Qmlu ZGluZy5oIgorI2luY2x1ZGUgIldlYktpdE11dGF0aW9uT2JzZXJ2ZXIuaCIKICNpbmNsdWRlICJX ZWJLaXRQbGF0Zm9ybVN1cHBvcnQuaCIKICNpbmNsdWRlICJXZWJNZWRpYVBsYXllckNsaWVudElt cGwuaCIKICNpbmNsdWRlICJXZWJTb2NrZXQuaCIKKyNpbmNsdWRlICJXZWJUaHJlYWQuaCIKICNp bmNsdWRlICJXb3JrZXJDb250ZXh0RXhlY3V0aW9uUHJveHkuaCIKICNpbmNsdWRlICJ2OC5oIgog CkBAIC01Miw2ICs1NCwyMiBAQAogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAorI2lmIEVOQUJMRShN VVRBVElPTl9PQlNFUlZFUlMpCituYW1lc3BhY2UgeworCitjbGFzcyBFbmRPZlRhc2tSdW5uZXIg OiBwdWJsaWMgV2ViVGhyZWFkOjpUYXNrT2JzZXJ2ZXIgeworcHVibGljOgorICAgIHZpcnR1YWwg dm9pZCBkaWRQcm9jZXNzVGFzaygpCisgICAgeworICAgICAgICBXZWJDb3JlOjpXZWJLaXRNdXRh dGlvbk9ic2VydmVyOjpkZWxpdmVyQWxsTXV0YXRpb25zKCk7CisgICAgfQorfTsKKworfSAvLyBu YW1lc3BhY2UKKworc3RhdGljIFdlYlRocmVhZDo6VGFza09ic2VydmVyKiBzX2VuZE9mVGFza1J1 bm5lciA9IDA7CisjZW5kaWYgLy8gRU5BQkxFKE1VVEFUSU9OX09CU0VSVkVSUykKKwogLy8gTWFr ZSBzdXJlIHdlIGFyZSBub3QgcmUtaW5pdGlhbGl6ZWQgaW4gdGhlIHNhbWUgYWRkcmVzcyBzcGFj ZS4KIC8vIERvaW5nIHNvIG1heSBjYXVzZSBoYXJkIHRvIHJlcHJvZHVjZSBjcmFzaGVzLgogc3Rh dGljIGJvb2wgc193ZWJLaXRJbml0aWFsaXplZCA9IGZhbHNlOwpAQCAtNzUsNiArOTMsMTIgQEAg dm9pZCBpbml0aWFsaXplKFdlYktpdFBsYXRmb3JtU3VwcG9ydCogd2ViS2l0UGxhdGZvcm1TdXBw b3J0KQogICAgIHY4OjpWODo6U2V0RW50cm9weVNvdXJjZSgmZ2VuZXJhdGVFbnRyb3B5KTsKICAg ICB2ODo6Vjg6OkluaXRpYWxpemUoKTsKICAgICBXZWJDb3JlOjpWOEJpbmRpbmdQZXJJc29sYXRl RGF0YTo6ZW5zdXJlSW5pdGlhbGl6ZWQodjg6Oklzb2xhdGU6OkdldEN1cnJlbnQoKSk7CisKKyNp ZiBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorICAgIEFTU0VSVCghc19lbmRPZlRhc2tSdW5u ZXIpOworICAgIHNfZW5kT2ZUYXNrUnVubmVyID0gbmV3IEVuZE9mVGFza1J1bm5lcjsKKyAgICB3 ZWJLaXRQbGF0Zm9ybVN1cHBvcnQtPmN1cnJlbnRUaHJlYWQoKS0+YWRkVGFza09ic2VydmVyKHNf ZW5kT2ZUYXNrUnVubmVyKTsKKyNlbmRpZgogfQogCiB2b2lkIGluaXRpYWxpemVXaXRob3V0Vjgo V2ViS2l0UGxhdGZvcm1TdXBwb3J0KiB3ZWJLaXRQbGF0Zm9ybVN1cHBvcnQpCkBAIC0xMDcsNiAr MTMxLDEzIEBAIHZvaWQgc2h1dGRvd24oKQogewogICAgIGRlbGV0ZSBXZWJDb3JlOjpDQ1Byb3h5 OjptYWluVGhyZWFkKCk7CiAgICAgV2ViQ29yZTo6Q0NQcm94eTo6c2V0TWFpblRocmVhZCgwKTsK KyNpZiBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorICAgIGlmIChzX2VuZE9mVGFza1J1bm5l cikgeworICAgICAgICBzX3dlYktpdFBsYXRmb3JtU3VwcG9ydC0+Y3VycmVudFRocmVhZCgpLT5y ZW1vdmVUYXNrT2JzZXJ2ZXIoc19lbmRPZlRhc2tSdW5uZXIpOworICAgICAgICBkZWxldGUgc19l bmRPZlRhc2tSdW5uZXI7CisgICAgICAgIHNfZW5kT2ZUYXNrUnVubmVyID0gMDsKKyAgICB9Cisj ZW5kaWYKICAgICBzX3dlYktpdFBsYXRmb3JtU3VwcG9ydCA9IDA7CiB9CiAK 117658 2011-12-02 11:19:09 -0800 2011-12-02 11:39:38 -0800 Patch for landing bug-71242-20111202111908.patch text/plain 4200 adamk U3VidmVyc2lvbiBSZXZpc2lvbjogMTAxODM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDZjNTZhNTVkMzNjZmNjMzdlZjRhYTEzYTdjODZmNzczZWEwYzk4MjEuLmQ3YTU3MjI1MTBmYzU0 ODIzODk1ODBhNmUwOTI1MjllODEzOTllM2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMjggQEAKKzIwMTEtMTEtMzAgIEFkYW0gS2xlaW4gIDxhZGFta0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBXZWJLaXRNdXRhdGlvbk9ic2VydmVyOjpkZWxpdmVy QWxsTXV0YXRpb25zIHNob3VsZCBiZSBleHBvc2VkIHRocm91Z2ggdGhlIENocm9taXVtIEFQSQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzEyNDIKKwor ICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBGaXNoZXIuCisKKyAgICAgICAgUmVsYW5kaW5nLCBk ZXBlbmRzIG9uIGh0dHA6Ly9jb2RlcmV2aWV3LmNocm9taXVtLm9yZy84NzQ4MDE1LworICAgICAg ICB0byBmaXggYSBzYW5kYm94aW5nIGlzc3VlIG9uIENocm9taXVtL0xpbnV4LgorCisgICAgICAg IEFkZCBhZGRUYXNrT2JzZXJ2ZXIgYW5kIHJlbW92ZVRhc2tPYnNlcnZlciB0byBXZWJUaHJlYWQs CisgICAgICAgIGFsb25nIHdpdGggYSBuZXcgV2ViVGhyZWFkOjpUYXNrT2JzZXJ2ZXIgaW50ZXJm YWNlLgorCisgICAgICAgIEZvciBtdXRhdGlvbiBvYnNlcnZlcnMsIGFkZCBhIFRhc2tPYnNlcnZl ciB0byB0aGUgbWFpbiB0aHJlYWQKKyAgICAgICAgdG8gZGVsaXZlciBtdXRhdGlvbnMgYWZ0ZXIg ZWFjaCB0YXNrIHJ1bnMuCisKKyAgICAgICAgVGhlIENocm9taXVtIGltcGxlbWVudGF0aW9uIG9m IHRoZSBuZXcgV2ViVGhyZWFkIG1ldGhvZHMgaXMgaW4KKyAgICAgICAgaHR0cDovL2NvZGVyZXZp ZXcuY2hyb21pdW0ub3JnLzg1ODYwMzgvLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dl YlRocmVhZC5oOgorICAgICAgICAoV2ViS2l0OjpXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlcjo6flRh c2tPYnNlcnZlcik6CisgICAgICAgICogc3JjL1dlYktpdC5jcHA6CisgICAgICAgIChXZWJLaXQ6 OmluaXRpYWxpemUpOgorICAgICAgICAoV2ViS2l0OjpzaHV0ZG93bik6CisKIDIwMTEtMTItMDIg IEFsb2sgUHJpeWFkYXJzaGkgIDxhbG9rcEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW2Nocm9t aXVtXSBDQ0xheWVyUXVhZCBkb2VzIG5vdCByZXR1cm4gRmxvYXRRdWFkIGluIGNvcnJlY3Qgb3Jp ZW50YXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRm b3JtL1dlYlRocmVhZC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0v V2ViVGhyZWFkLmgKaW5kZXggZGIyNTU1NmY5ZmVjZTY4ZTZiZTZlZDM4ZjBkYTgyMjljMGY3ZWUy YS4uYTdiMzcyZmVlMzRkN2RmZDljN2NhMTY0NTEzMmZlMDQ5YzBiNjg1YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViVGhyZWFkLmgKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViVGhyZWFkLmgKQEAgLTQz LDggKzQzLDE2IEBAIHB1YmxpYzoKICAgICAgICAgdmlydHVhbCB2b2lkIHJ1bigpID0gMDsKICAg ICB9OwogCisgICAgY2xhc3MgVGFza09ic2VydmVyIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZp cnR1YWwgflRhc2tPYnNlcnZlcigpIHsgfQorICAgICAgICB2aXJ0dWFsIHZvaWQgZGlkUHJvY2Vz c1Rhc2soKSA9IDA7CisgICAgfTsKKwogICAgIHZpcnR1YWwgdm9pZCBwb3N0VGFzayhUYXNrKikg PSAwOwogICAgIHZpcnR1YWwgdm9pZCBwb3N0RGVsYXllZFRhc2soVGFzayosIGxvbmcgbG9uZyBk ZWxheU1zKSA9IDA7CisgICAgdmlydHVhbCB2b2lkIGFkZFRhc2tPYnNlcnZlcihUYXNrT2JzZXJ2 ZXIqKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlVGFza09ic2VydmVyKFRhc2tPYnNlcnZl ciopIHsgfQogCiAgICAgdmlydHVhbCB+V2ViVGhyZWFkKCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYktpdC5jcHAKaW5kZXggNjJiNDE4MDhkNzA1MzE4ZTA1NTA5YzcyZTk2M2Y2 ZmY4MjJmMWNjZS4uMDk5ZGM5NWZjYmFiMTA2ZjE2NjJmMTc4YzA3ZWVhODBkOWNmNGNiYSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViS2l0LmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJLaXQuY3BwCkBAIC0zNyw5ICszNywxMSBAQAogI2lu Y2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiVGV4dEVuY29kaW5nLmgiCiAjaW5jbHVkZSAi VjhCaW5kaW5nLmgiCisjaW5jbHVkZSAiV2ViS2l0TXV0YXRpb25PYnNlcnZlci5oIgogI2luY2x1 ZGUgIldlYktpdFBsYXRmb3JtU3VwcG9ydC5oIgogI2luY2x1ZGUgIldlYk1lZGlhUGxheWVyQ2xp ZW50SW1wbC5oIgogI2luY2x1ZGUgIldlYlNvY2tldC5oIgorI2luY2x1ZGUgIldlYlRocmVhZC5o IgogI2luY2x1ZGUgIldvcmtlckNvbnRleHRFeGVjdXRpb25Qcm94eS5oIgogI2luY2x1ZGUgInY4 LmgiCiAKQEAgLTUwLDYgKzUyLDIyIEBACiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCisjaWYgRU5B QkxFKE1VVEFUSU9OX09CU0VSVkVSUykKK25hbWVzcGFjZSB7CisKK2NsYXNzIEVuZE9mVGFza1J1 bm5lciA6IHB1YmxpYyBXZWJUaHJlYWQ6OlRhc2tPYnNlcnZlciB7CitwdWJsaWM6CisgICAgdmly dHVhbCB2b2lkIGRpZFByb2Nlc3NUYXNrKCkKKyAgICB7CisgICAgICAgIFdlYkNvcmU6OldlYktp dE11dGF0aW9uT2JzZXJ2ZXI6OmRlbGl2ZXJBbGxNdXRhdGlvbnMoKTsKKyAgICB9Cit9OworCit9 IC8vIG5hbWVzcGFjZQorCitzdGF0aWMgV2ViVGhyZWFkOjpUYXNrT2JzZXJ2ZXIqIHNfZW5kT2ZU YXNrUnVubmVyID0gMDsKKyNlbmRpZiAvLyBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorCiAv LyBNYWtlIHN1cmUgd2UgYXJlIG5vdCByZS1pbml0aWFsaXplZCBpbiB0aGUgc2FtZSBhZGRyZXNz IHNwYWNlLgogLy8gRG9pbmcgc28gbWF5IGNhdXNlIGhhcmQgdG8gcmVwcm9kdWNlIGNyYXNoZXMu CiBzdGF0aWMgYm9vbCBzX3dlYktpdEluaXRpYWxpemVkID0gZmFsc2U7CkBAIC03Myw2ICs5MSwx MiBAQCB2b2lkIGluaXRpYWxpemUoV2ViS2l0UGxhdGZvcm1TdXBwb3J0KiB3ZWJLaXRQbGF0Zm9y bVN1cHBvcnQpCiAgICAgdjg6OlY4OjpTZXRFbnRyb3B5U291cmNlKCZnZW5lcmF0ZUVudHJvcHkp OwogICAgIHY4OjpWODo6SW5pdGlhbGl6ZSgpOwogICAgIFdlYkNvcmU6OlY4QmluZGluZ1Blcklz b2xhdGVEYXRhOjplbnN1cmVJbml0aWFsaXplZCh2ODo6SXNvbGF0ZTo6R2V0Q3VycmVudCgpKTsK KworI2lmIEVOQUJMRShNVVRBVElPTl9PQlNFUlZFUlMpCisgICAgQVNTRVJUKCFzX2VuZE9mVGFz a1J1bm5lcik7CisgICAgc19lbmRPZlRhc2tSdW5uZXIgPSBuZXcgRW5kT2ZUYXNrUnVubmVyOwor ICAgIHdlYktpdFBsYXRmb3JtU3VwcG9ydC0+Y3VycmVudFRocmVhZCgpLT5hZGRUYXNrT2JzZXJ2 ZXIoc19lbmRPZlRhc2tSdW5uZXIpOworI2VuZGlmCiB9CiAKIHZvaWQgaW5pdGlhbGl6ZVdpdGhv dXRWOChXZWJLaXRQbGF0Zm9ybVN1cHBvcnQqIHdlYktpdFBsYXRmb3JtU3VwcG9ydCkKQEAgLTEw MSw2ICsxMjUsMTMgQEAgdm9pZCBpbml0aWFsaXplV2l0aG91dFY4KFdlYktpdFBsYXRmb3JtU3Vw cG9ydCogd2ViS2l0UGxhdGZvcm1TdXBwb3J0KQogCiB2b2lkIHNodXRkb3duKCkKIHsKKyNpZiBF TkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKQorICAgIGlmIChzX2VuZE9mVGFza1J1bm5lcikgewor ICAgICAgICBzX3dlYktpdFBsYXRmb3JtU3VwcG9ydC0+Y3VycmVudFRocmVhZCgpLT5yZW1vdmVU YXNrT2JzZXJ2ZXIoc19lbmRPZlRhc2tSdW5uZXIpOworICAgICAgICBkZWxldGUgc19lbmRPZlRh c2tSdW5uZXI7CisgICAgICAgIHNfZW5kT2ZUYXNrUnVubmVyID0gMDsKKyAgICB9CisjZW5kaWYK ICAgICBzX3dlYktpdFBsYXRmb3JtU3VwcG9ydCA9IDA7CiB9CiAK