193758 2019-01-23 20:59:24 -0800 [iOS] Unable to make a selection in jsfiddle.net using arrow keys when requesting desktop site 2019-02-04 22:13:00 -0800 1 1 1 Unclassified WebKit Forms WebKit Nightly Build Unspecified Unspecified REOPENED InRadar P2 Normal --- 1 wenson_hsieh wenson_hsieh bdakin cdumez commit-queue corsar89 dbates rniwa thorton webkit-bug-importer wenson_hsieh oldest_to_newest 1497720 0 wenson_hsieh 2019-01-23 20:59:24 -0800 To reproduce: 1. Install iOS 12 2. Go to jsfiddle.net and request the desktop site 2. Type text in any of the HTML/JS/CSS editors 3. Using cmd+A or shift+arrow keys, attempt to make a "selection" Observe that the "selection" is immediately dismissed. 1497721 1 wenson_hsieh 2019-01-23 21:01:07 -0800 This also repros on coderpad.io. 1497723 2 wenson_hsieh 2019-01-23 21:01:25 -0800 <rdar://problem/43614978> 1497724 3 wenson_hsieh 2019-01-23 21:02:06 -0800 (In reply to Wenson Hsieh from comment #0) > To reproduce: (Step 0: use an iPad with a hardware keyboard!) > 1. Install iOS 12 > 2. Go to jsfiddle.net and request the desktop site > 2. Type text in any of the HTML/JS/CSS editors > 3. Using cmd+A or shift+arrow keys, attempt to make a "selection" > > Observe that the "selection" is immediately dismissed. 1497746 4 359995 wenson_hsieh 2019-01-23 22:45:39 -0800 Created attachment 359995 Patch for EWS 1497747 5 thorton 2019-01-23 23:25:56 -0800 This is ridiculous. 1497748 6 359995 thorton 2019-01-23 23:27:58 -0800 Comment on attachment 359995 Patch for EWS View in context: https://bugs.webkit.org/attachment.cgi?id=359995&action=review > Source/WebCore/html/HTMLTextFormControlElement.cpp:-195 > - // We don't want to select all the text on iOS. Instead use the standard textfield behavior of going to the end of the line. That said, isn't this comment true? We don't generally expect selection to appear out of thin air when you select an input. I assume that /doesn't/ happen? 1497751 7 359995 wenson_hsieh 2019-01-23 23:44:04 -0800 Comment on attachment 359995 Patch for EWS View in context: https://bugs.webkit.org/attachment.cgi?id=359995&action=review >> Source/WebCore/html/HTMLTextFormControlElement.cpp:-195 >> - // We don't want to select all the text on iOS. Instead use the standard textfield behavior of going to the end of the line. > > That said, isn't this comment true? We don't generally expect selection to appear out of thin air when you select an input. I assume that /doesn't/ happen? Well, it's true that we don't want to select all the text on iOS when focusing a text field. The way I understand it, Element.focus() is analogous to the platform's -becomeFirstResponder, and both of these don't select the entire contents of the text field. I /think/ this is what this comment was attempting to convey... However, select() is different from focus() in that it does not have a direct UIKit analogy; instead, its behavior is determined by the HTML spec, and should definitely adhere to that definition. I suppose I'm not entirely sure what it means to "select an input" in the context of the comment! 1497901 8 wenson_hsieh 2019-01-24 11:55:10 -0800 (In reply to Wenson Hsieh from comment #7) > Comment on attachment 359995 [details] > Patch for EWS > > View in context: > https://bugs.webkit.org/attachment.cgi?id=359995&action=review > > >> Source/WebCore/html/HTMLTextFormControlElement.cpp:-195 > >> - // We don't want to select all the text on iOS. Instead use the standard textfield behavior of going to the end of the line. > > > > That said, isn't this comment true? We don't generally expect selection to appear out of thin air when you select an input. I assume that /doesn't/ happen? > > Well, it's true that we don't want to select all the text on iOS when > focusing a text field. The way I understand it, Element.focus() is analogous > to the platform's -becomeFirstResponder, and both of these don't select the > entire contents of the text field. I /think/ this is what this comment was > attempting to convey... > > However, select() is different from focus() in that it does not have a > direct UIKit analogy; instead, its behavior is determined by the HTML spec, > and should definitely adhere to that definition. > > I suppose I'm not entirely sure what it means to "select an input" in the > context of the comment! So digging into this a bit further, it looks like: - This patch would make it so that calling focus() on iOS will select the text content of a text field, if the selection hasn't been set previously in the text field. This makes iOS behavior match behavior in macOS. - However, on macOS, native NSTextFields actually exhibit this same behavior (becoming first responder selects all the text in the field!) - On iOS, when native UITextFields become first responder, we don't select the entire text in the UITextField. ...so on iOS, we probably ought to still have focus() match platform behavior (i.e. -[UITextField becomeFirstResponder]). Of course, the select() method should still select all the contents of the text field, since that's what the HTML spec mandates. 1497956 9 360037 wenson_hsieh 2019-01-24 14:22:03 -0800 Created attachment 360037 v2 1497992 10 360037 commit-queue 2019-01-24 15:30:43 -0800 Comment on attachment 360037 v2 Clearing flags on attachment: 360037 Committed r240452: <https://trac.webkit.org/changeset/240452> 1497993 11 commit-queue 2019-01-24 15:30:44 -0800 All reviewed patches have been landed. Closing bug. 1501563 12 wenson_hsieh 2019-02-02 18:34:11 -0800 *** Bug 193040 has been marked as a duplicate of this bug. *** 1501564 13 360037 rniwa 2019-02-02 18:44:22 -0800 Comment on attachment 360037 v2 View in context: https://bugs.webkit.org/attachment.cgi?id=360037&action=review > Source/WebCore/html/HTMLInputElement.cpp:472 > +#if PLATFORM(IOS_FAMILY) We should tie this to the iOS editing behavior instead of a compile time flag like this. 1501662 14 wenson_hsieh 2019-02-03 12:37:02 -0800 (In reply to Ryosuke Niwa from comment #13) > Comment on attachment 360037 [details] > v2 > > View in context: > https://bugs.webkit.org/attachment.cgi?id=360037&action=review > > > Source/WebCore/html/HTMLInputElement.cpp:472 > > +#if PLATFORM(IOS_FAMILY) > > We should tie this to the iOS editing behavior instead of a compile time > flag like this. Good catch. Reopening to make this adjustment... 1501669 15 361025 wenson_hsieh 2019-02-03 13:12:58 -0800 Created attachment 361025 Use EditingBehavior 1501741 16 361025 dbates 2019-02-03 22:10:03 -0800 Comment on attachment 361025 Use EditingBehavior View in context: https://bugs.webkit.org/attachment.cgi?id=361025&action=review > Source/WebCore/html/HTMLInputElement.cpp:474 > + auto frame = makeRefPtr(document().frame()); Is it necessary to take out a RefPtr for this? This seems like some next-level craziness or paranoia if anyone along this chain to shouldMove...() were to cause frame destruction and the world might as well end if shouldMove...() is the one that causes it. Not a big thing in the grand scheme of things, but definitely not minimal. 1501743 17 361025 dbates 2019-02-03 22:17:23 -0800 Comment on attachment 361025 Use EditingBehavior View in context: https://bugs.webkit.org/attachment.cgi?id=361025&action=review > Source/WebCore/html/HTMLInputElement.cpp:479 > setSelectionRange(start, std::numeric_limits<int>::max(), direction, revealMode, Element::defaultFocusTextStateChangeIntent()); Why don't we just bail out early if we don't have a frame? Does setSelectionRange() do this? If it does, why not bail out before calling it? 1501744 18 361025 wenson_hsieh 2019-02-03 22:31:22 -0800 Comment on attachment 361025 Use EditingBehavior View in context: https://bugs.webkit.org/attachment.cgi?id=361025&action=review >> Source/WebCore/html/HTMLInputElement.cpp:474 >> + auto frame = makeRefPtr(document().frame()); > > Is it necessary to take out a RefPtr for this? This seems like some next-level craziness or paranoia if anyone along this chain to shouldMove...() were to cause frame destruction and the world might as well end if shouldMove...() is the one that causes it. Not a big thing in the grand scheme of things, but definitely not minimal. Fair enough. It's not incorrect to use a raw pointer here. But note that in the future, if any code were to run after calling setSelectionRange() that uses this raw Frame pointer, it would be a potential UAF. >> Source/WebCore/html/HTMLInputElement.cpp:479 >> setSelectionRange(start, std::numeric_limits<int>::max(), direction, revealMode, Element::defaultFocusTextStateChangeIntent()); > > Why don't we just bail out early if we don't have a frame? Does setSelectionRange() do this? If it does, why not bail out before calling it? setSelectionRange() does not bail early if frame is null. But as far as I can tell, the only state change it makes (besides updating layout) is calling `cacheSelection`. So it /seems/ like it should be safe to bail early, both in setSelectionRange and all of the helper methods that wrap it (e.g. setSelectionStart, setSelectionEnd, setSelectionDirection, select, setDefaultSelectionAfterFocus...). Regardless, this seems like a bigger change than is necessary for this patch, which is just about removing the compile-time guard. How do you feel about making this a separate change? 1501750 19 361025 dbates 2019-02-03 22:58:40 -0800 Comment on attachment 361025 Use EditingBehavior View in context: https://bugs.webkit.org/attachment.cgi?id=361025&action=review >>> Source/WebCore/html/HTMLInputElement.cpp:474 >>> + auto frame = makeRefPtr(document().frame()); >> >> Is it necessary to take out a RefPtr for this? This seems like some next-level craziness or paranoia if anyone along this chain to shouldMove...() were to cause frame destruction and the world might as well end if shouldMove...() is the one that causes it. Not a big thing in the grand scheme of things, but definitely not minimal. > > Fair enough. It's not incorrect to use a raw pointer here. But note that in the future, if any code were to run after calling setSelectionRange() that uses this raw Frame pointer, it would be a potential UAF. FYI, not really opposed to the makeRefPtr(). I think it's silly in this case, but r=me I am not going to stop you for it. I don't know anymore what is good engineering practice for dealing with this. UAF is bad. However, this paranoia you have for code after calling setSelection..()... that's setSelection...()'s problem. That function should take out the ref if it needs lifetime guarantees not its caller or it's caller's caller or its caller's caller's caller or 50 caller's up. If we're at that level of craziness then garbage collecting the world doesn't seem half bad. I don't want to be responsible for a UAF and I don't have a checkout at the moment to audit the code to say with any level confidence other than gut feeling that we won't have a UAF. But I can say this... the code here doesn't take out a ref of the frame for setSelection...() so we have the situation you describe then we have a UAF now. I say, fix setSelec..() and everyone else that needs lifetime guarantees. >>> Source/WebCore/html/HTMLInputElement.cpp:479 >>> setSelectionRange(start, std::numeric_limits<int>::max(), direction, revealMode, Element::defaultFocusTextStateChangeIntent()); >> >> Why don't we just bail out early if we don't have a frame? Does setSelectionRange() do this? If it does, why not bail out before calling it? > > setSelectionRange() does not bail early if frame is null. But as far as I can tell, the only state change it makes (besides updating layout) is calling `cacheSelection`. So it /seems/ like it should be safe to bail early, both in setSelectionRange and all of the helper methods that wrap it (e.g. setSelectionStart, setSelectionEnd, setSelectionDirection, select, setDefaultSelectionAfterFocus...). Regardless, this seems like a bigger change than is necessary for this patch, which is just about removing the compile-time guard. > > How do you feel about making this a separate change? No preference. Just wanted ask. 1501814 20 361054 wenson_hsieh 2019-02-04 07:33:53 -0800 Created attachment 361054 Patch for landing 1501831 21 361054 commit-queue 2019-02-04 08:05:23 -0800 Comment on attachment 361054 Patch for landing Clearing flags on attachment: 361054 Committed r240926: <https://trac.webkit.org/changeset/240926> 1501926 22 361054 rniwa 2019-02-04 11:35:21 -0800 Comment on attachment 361054 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=361054&action=review > Source/WebCore/html/HTMLInputElement.cpp:475 > + if (frame && frame->editor().behavior().shouldMoveSelectionToEndWhenFocusingTextInput()) { Document has settings. We should use that. I *think* this has a bug that an input element whose document is not in a frame won't respect this iOS behavior. I *think* selectionStart & selectionEnd are always observable on an input element regardless of whether the element is in a document or its document is detached from frame. 1501932 23 361054 wenson_hsieh 2019-02-04 11:43:43 -0800 Comment on attachment 361054 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=361054&action=review >> Source/WebCore/html/HTMLInputElement.cpp:475 >> + if (frame && frame->editor().behavior().shouldMoveSelectionToEndWhenFocusingTextInput()) { > > Document has settings. We should use that. > I *think* this has a bug that an input element whose document is not in a frame won't respect this iOS behavior. > I *think* selectionStart & selectionEnd are always observable on an input element > regardless of whether the element is in a document or its document is detached from frame. Okay. Definitely sounds worth addressing. I think there are three ways to do this, and I'm not sure which is preferable. Do you have any opinions about whether we should: (A) Add an editingBehavior() getter to Settings, or (B) Add an editingBehavior() getter to Document, or (C) Check directly against editingBehaviorType(), and not go through EditingBehavior? 1501987 24 rniwa 2019-02-04 13:27:02 -0800 (In reply to Wenson Hsieh from comment #23) > Comment on attachment 361054 [details] > Patch for landing > > View in context: > https://bugs.webkit.org/attachment.cgi?id=361054&action=review > > >> Source/WebCore/html/HTMLInputElement.cpp:475 > >> + if (frame && frame->editor().behavior().shouldMoveSelectionToEndWhenFocusingTextInput()) { > > > > Document has settings. We should use that. > > I *think* this has a bug that an input element whose document is not in a frame won't respect this iOS behavior. > > I *think* selectionStart & selectionEnd are always observable on an input element > > regardless of whether the element is in a document or its document is detached from frame. > > Okay. Definitely sounds worth addressing. I think there are three ways to do > this, and I'm not sure which is preferable. Do you have any opinions about > whether we should: > (A) Add an editingBehavior() getter to Settings, or > (B) Add an editingBehavior() getter to Document, or > (C) Check directly against editingBehaviorType(), and not go through > EditingBehavior? Oh, interesting. editingBehavior is on Editor but the code seems to indicate that we only need settings really: EditingBehavior Editor::behavior() const { return EditingBehavior(m_frame.settings().editingBehaviorType()); } We could even create a new EditingBehavior to ask the same question if we wanted. Alternatively, we can move it to Settings, or add a new getter on Settings. 1501989 25 361054 wenson_hsieh 2019-02-04 13:31:26 -0800 Comment on attachment 361054 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=361054&action=review >>>> Source/WebCore/html/HTMLInputElement.cpp:475 >>>> + if (frame && frame->editor().behavior().shouldMoveSelectionToEndWhenFocusingTextInput()) { >>> >>> Document has settings. We should use that. >>> I *think* this has a bug that an input element whose document is not in a frame won't respect this iOS behavior. >>> I *think* selectionStart & selectionEnd are always observable on an input element >>> regardless of whether the element is in a document or its document is detached from frame. >> >> Okay. Definitely sounds worth addressing. I think there are three ways to do this, and I'm not sure which is preferable. Do you have any opinions about whether we should: >> (A) Add an editingBehavior() getter to Settings, or >> (B) Add an editingBehavior() getter to Document, or >> (C) Check directly against editingBehaviorType(), and not go through EditingBehavior? > > Oh, interesting. editingBehavior is on Editor but the code seems to indicate that we only need settings really: > > EditingBehavior Editor::behavior() const > { > return EditingBehavior(m_frame.settings().editingBehaviorType()); > } > > We could even create a new EditingBehavior to ask the same question if we wanted. Alternatively, we can move it to Settings, or add a new getter on Settings. The last plan sounds good — I'll add a new getter on Settings (plan (A) above) then, and post a patch shortly. Thanks! 1502065 26 361054 wenson_hsieh 2019-02-04 15:34:26 -0800 Comment on attachment 361054 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=361054&action=review >>>>> Source/WebCore/html/HTMLInputElement.cpp:475 >>>>> + if (frame && frame->editor().behavior().shouldMoveSelectionToEndWhenFocusingTextInput()) { >>>> >>>> Document has settings. We should use that. >>>> I *think* this has a bug that an input element whose document is not in a frame won't respect this iOS behavior. >>>> I *think* selectionStart & selectionEnd are always observable on an input element >>>> regardless of whether the element is in a document or its document is detached from frame. >>> >>> Okay. Definitely sounds worth addressing. I think there are three ways to do this, and I'm not sure which is preferable. Do you have any opinions about whether we should: >>> (A) Add an editingBehavior() getter to Settings, or >>> (B) Add an editingBehavior() getter to Document, or >>> (C) Check directly against editingBehaviorType(), and not go through EditingBehavior? >> >> Oh, interesting. editingBehavior is on Editor but the code seems to indicate that we only need settings really: >> >> EditingBehavior Editor::behavior() const >> { >> return EditingBehavior(m_frame.settings().editingBehaviorType()); >> } >> >> We could even create a new EditingBehavior to ask the same question if we wanted. Alternatively, we can move it to Settings, or add a new getter on Settings. > > The last plan sounds good — I'll add a new getter on Settings (plan (A) above) then, and post a patch shortly. > > Thanks! Introducing an editingBehavior getter on Settings is actually not straightforward, unless we add support for a new type of readonly entry in Settings.yaml, or add a virtual editingBehavior() method on SettingsBase. I'm going to put this getter on Document instead. 1502070 27 wenson_hsieh 2019-02-04 15:41:51 -0800 Reopening to attach new patch. 1502072 28 361112 wenson_hsieh 2019-02-04 15:41:52 -0800 Created attachment 361112 Patch 1502079 29 361117 wenson_hsieh 2019-02-04 16:04:15 -0800 Created attachment 361117 Patch 1502225 30 dbates 2019-02-04 19:46:10 -0800 Have we confirmed the premise about selection being queryable from a frameless document? If so, why not add a test? 1502226 31 dbates 2019-02-04 19:47:29 -0800 I am kinda surprised since I seem to recall selection tied to the frame. 1502258 32 wenson_hsieh 2019-02-04 22:01:47 -0800 (In reply to Daniel Bates from comment #31) > I am kinda surprised since I seem to recall selection tied to the frame. Right, but I think in this case it's about the input element's selectionStart and selectionEnd, which are saved in cached values even if the DOM selection is moved. I tried briefly to devise a test for this scenario, but couldn't. It essentially involved loading an iframe with a text field, saving a reference to the text field, disconnecting the frame, and then manipulating the text field to try and get bogus values for selectionStart and selectionEnd. ...but to no avail :/ 1502259 33 rniwa 2019-02-04 22:13:00 -0800 Hm... yeah, all sorts of things appear to be broken once the document loses its frame. I think what's broken here isn't so much the cached selection of the input element but the focusing, etc... 359995 2019-01-23 22:45:39 -0800 2019-01-24 14:22:01 -0800 Patch for EWS bug-193758-20190123224539.patch text/plain 14641 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjQwMzUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2YyMTE4Yjk1ZDViNTEy Nzk0YzkxY2Q3YWUzYzJmOTBlNjlhOWI2NS4uYjdiYmY0ZWI0ODgxNDM3NjIzN2JkNjNiYjU5ODVj MDVmYjhlOTYwOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDE5LTAxLTIzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJs ZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdo ZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE5Mzc1OAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNDM2MTQ5 Nzg+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ29k ZU1pcnJvcidzIHNjcmlwdCBhZGRzIGEgcmVwZWF0aW5nIHRpbWVyIHRoYXQgcGVyaW9kaWNhbGx5 IG5vcm1hbGl6ZXMgdGhlIGxvZ2ljYWwgc2VsZWN0aW9uIGluIHRoZSBlZGl0b3IKKyAgICAgICAg KHRoaXMgaXMgZGlzdGluY3QgZnJvbSB0aGUgYWN0dWFsIERPTSBzZWxlY3Rpb24sIHdoaWNoIGlz IGluc2lkZSBhIGhpZGRlbiB0ZXh0YXJlYSBlbGVtZW50KS4gVGhpcyBzY3JpcHQgZGVmaW5lcwor ICAgICAgICBhIGhlbHBlciBtZXRob2QgdG8gc2VsZWN0IGFsbCB0aGUgdGV4dCBpbnNpZGUgb2Yg YSB0ZXh0IGZvcm0gY29udHJvbCwgY2FsbGVkIGBzZWxlY3RJbnB1dGAsIHdoaWNoIG5vcm1hbGx5 CisgICAgICAgIGludm9rZXMgYG5vZGUuc2VsZWN0KClgLiBIb3dldmVyLCBpbiB0aGUgY2FzZSBv ZiBpT1MsIHRoZSBzY3JpcHQgd29ya3MgYXJvdW5kIGJyb2tlbiBgc2VsZWN0KClgIGJlaGF2aW9y IGJ5CisgICAgICAgIHNldHRpbmcgYHNlbGVjdGlvblN0YXJ0YCBhbmQgYHNlbGVjdGlvbkVuZGAg dG8gZW5jb21wYXNzIGFsbCB0aGUgY29udGVudCBpbiB0aGUgZm9ybSBjb250cm9sLiBXaGVuIHJl cXVlc3RpbmcKKyAgICAgICAgdGhlIGRlc2t0b3AgdmVyc2lvbiBvZiB0aGUgc2l0ZSwgQ29kZU1p cnJvciBubyBsb25nZXIgYXR0ZW1wdHMgdG8gYXBwbHkgaXRzIGlPUyB3b3JrYXJvdW5kLgorCisg ICAgICAgIFRoaXMgaU9TLXNwZWNpZmljIGJlaGF2aW9yIHdhcyBpbnRyb2R1Y2VkIHRvIGZpeCA8 cmRhcjovL3Byb2JsZW0vNDkwMTkyMz4uIEhvd2V2ZXIsIHRoZSBvcmlnaW5hbCBidWcgbm8gbG9u Z2VyCisgICAgICAgIHJlcHJvZHVjZXMgZXZlbiB3aXRob3V0IHRoaXMgcXVpcmsuIFRvIGZpeCB0 aGlzIGJ1Zywgd2UgY2FuIHNpbXBseSByb2xsIG91dCB0aGlzIGFuY2llbnQgZGVtbyBoYWNrLCBp biBmYXZvciBvZgorICAgICAgICBzdGFuZGFyZGl6ZWQgYmVoYXZpb3IuCisKKyAgICAgICAgVGhp cyBjYXVzZXMgMTEgZXhpc3RpbmcgbGF5b3V0IHRlc3RzIHRvIGJlZ2luIHBhc3Npbmcgb24gaU9T LCBhbmQgaXMgYWxzbyBjb3ZlcmVkIGJ5IHJlYmFzZWxpbmluZyBzb21lIG1vcmUgdGVzdAorICAg ICAgICBleHBlY3RhdGlvbnMgdG8gYmUgY29uc2lzdGVudCB3aXRoIG1hY09TLgorCisgICAgICAg ICogaHRtbC9IVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6c2VsZWN0KToKKwogMjAxOS0wMS0yMyAgV2Vu c29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBOZWVkIGEgd2F5 IGZvciBKYXZhU2NyaXB0IChvciBidW5kbGUpIGNvZGUgdG8gcGFydGljaXBhdGUgaW4gdW5kbwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEZvcm1Db250cm9sRWxlbWVu dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50LmNw cAppbmRleCAxNWJmMjcxOTJkZjczMDY1NTMwZjgxMmEwNmIzMGM2Zjc4ODhhMWUwLi44MTM2OTMz YWQ1NTRjNWExZjdlMGM2Y2E3ODc5ZDk2NWVmYzNkY2E5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL0hUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50LmNwcApAQCAtMTg5LDE0ICsxODks NyBAQCB2b2lkIEhUTUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50OjpzZXRTZWxlY3Rpb25EaXJlY3Rp b24oY29uc3QgU3RyaW5nJiBkaXJlY3Rpb24pCiAKIHZvaWQgSFRNTFRleHRGb3JtQ29udHJvbEVs ZW1lbnQ6OnNlbGVjdChTZWxlY3Rpb25SZXZlYWxNb2RlIHJldmVhbE1vZGUsIGNvbnN0IEFYVGV4 dFN0YXRlQ2hhbmdlSW50ZW50JiBpbnRlbnQpCiB7Ci0gICAgLy8gRklYTUU6IFdlIHNob3VsZCBh YnN0cmFjdCB0aGUgc2VsZWN0aW9uIGJlaGF2aW9yIGludG8gYW4gRWRpdGluZ0JlaGF2aW9yIGZ1 bmN0aW9uIGluc3RlYWQKLSAgICAvLyBvZiBoYXJkY29kaW5nIHRoZSBiZWhhdmlvciB1c2luZyBh IG1hY3JvIGRlZmluZS4KLSNpZiBQTEFURk9STShJT1NfRkFNSUxZKQotICAgIC8vIFdlIGRvbid0 IHdhbnQgdG8gc2VsZWN0IGFsbCB0aGUgdGV4dCBvbiBpT1MuIEluc3RlYWQgdXNlIHRoZSBzdGFu ZGFyZCB0ZXh0ZmllbGQgYmVoYXZpb3Igb2YgZ29pbmcgdG8gdGhlIGVuZCBvZiB0aGUgbGluZS4K LSAgICBzZXRTZWxlY3Rpb25SYW5nZShzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpLCBz dGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpLCBTZWxlY3Rpb25IYXNGb3J3YXJkRGlyZWN0 aW9uLCByZXZlYWxNb2RlLCBpbnRlbnQpOwotI2Vsc2UKICAgICBzZXRTZWxlY3Rpb25SYW5nZSgw LCBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpLCBTZWxlY3Rpb25IYXNOb0RpcmVjdGlv biwgcmV2ZWFsTW9kZSwgaW50ZW50KTsKLSNlbmRpZgogfQogCiBTdHJpbmcgSFRNTFRleHRGb3Jt Q29udHJvbEVsZW1lbnQ6OnNlbGVjdGVkVGV4dCgpIGNvbnN0CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggM2EyNTFmNjczZDgz ODBkOGQ4Mjg1MjhjMzMyOTlkMWUzNDlkYjAyZC4uMDE2ODkzMzZmNWQ4ODdmMzRlZDgxYmVkMzA4 YmM2MTI5Y2Y5ZWVkMyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIyIEBACisyMDE5LTAxLTIzICBXZW5zb24g SHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJsZSB0 byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdoZW4g cmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE5Mzc1OAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNDM2MTQ5Nzg+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmViYXNl bGluZSBpT1MgZXhwZWN0YXRpb24gZm9yIGEgZmV3IGV4aXN0aW5nIGxheW91dCB0ZXN0cywgYW5k IGFkZGl0aW9uYWxseSB1bm1hcmsgYSBudW1iZXIgb2YgY3VycmVudGx5CisgICAgICAgIGZhaWxp bmcgdGVzdHMgb24gaU9TLgorCisgICAgICAgICogcGxhdGZvcm0vaW9zLXdrMi9mYXN0L2Zvcm1z L3RleHRmaWVsZC1vdXRsaW5lLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiBwbGF0Zm9ybS9pb3Mv VGVzdEV4cGVjdGF0aW9uczoKKyAgICAgICAgKiBwbGF0Zm9ybS9pb3MvZWRpdGluZy90ZXh0LWl0 ZXJhdG9yL2hpZGRlbi10ZXh0YXJlYS1zZWxlY3Rpb24tcXVpcmstZXhwZWN0ZWQudHh0OiBSZW1v dmVkLgorICAgICAgICAqIHBsYXRmb3JtL2lvcy9mYXN0L2Zvcm1zL2lucHV0LWFwcGVhcmFuY2Ut Zm9jdXMtZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHBsYXRmb3JtL2lvcy9mYXN0L2Zvcm1zL2lu cHV0LWFwcGVhcmFuY2UtcmVhZG9ubHktZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHBsYXRmb3Jt L2lvcy9mYXN0L2Zvcm1zL2lucHV0LWRvdWJsZS1jbGljay1zZWxlY3Rpb24tZ2FwLWJ1Zy1leHBl Y3RlZC50eHQ6CisgICAgICAgICogcGxhdGZvcm0vaW9zL2Zhc3QvZm9ybXMvdGV4dGZpZWxkLW91 dGxpbmUtZXhwZWN0ZWQudHh0OgorCiAyMDE5LTAxLTIzICBXZW5zb24gSHNpZWggIDx3ZW5zb25f aHNpZWhAYXBwbGUuY29tPgogCiAgICAgICAgIE5lZWQgYSB3YXkgZm9yIEphdmFTY3JpcHQgKG9y IGJ1bmRsZSkgY29kZSB0byBwYXJ0aWNpcGF0ZSBpbiB1bmRvCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL2Zhc3QvZm9ybXMvdGV4dGZpZWxkLW91dGxpbmUtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zLXdrMi9mYXN0L2Zvcm1zL3RleHRmaWVs ZC1vdXRsaW5lLWV4cGVjdGVkLnR4dAppbmRleCA0NWQ5M2FlNDBiODg2MGZiNTE2ZTgyZDc4NTMy ZDliNGM5NDBlODIxLi5jMzM4MGE0Y2M1N2E5MzRmOGJkOWQ3MTZhYTE3YTIzODFmOWY2NGFmIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtd2syL2Zhc3QvZm9ybXMvdGV4dGZp ZWxkLW91dGxpbmUtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy13 azIvZmFzdC9mb3Jtcy90ZXh0ZmllbGQtb3V0bGluZS1leHBlY3RlZC50eHQKQEAgLTEyLDQgKzEy LDUgQEAgbGF5ZXIgYXQgKDIxLDM1KSBzaXplIDIyMngyNSBzY3JvbGxYIDI5MiBzY3JvbGxXaWR0 aCA1MTIKICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDExLDUpIHNpemUgMjIzeDI1CiAgICAgUmVu ZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgNTExeDI1CiAgICAgICB0ZXh0IHJ1biBhdCAo MCwwKSB3aWR0aCA1MTE6ICJUaGlzIHRlc3RzIHRoYXQgdHlwaW5nIGRvZXNuJ3QgY3V0IGhvbGVz IGluIHRoZSBmb2N1cyBvdXRsaW5lIgotY2FyZXQ6IHBvc2l0aW9uIDYxIG9mIGNoaWxkIDAgeyN0 ZXh0fSBvZiBjaGlsZCAwIHtESVZ9IG9mIHsjZG9jdW1lbnQtZnJhZ21lbnR9IG9mIGNoaWxkIDMg e0lOUFVUfSBvZiBib2R5CitzZWxlY3Rpb24gc3RhcnQ6IHBvc2l0aW9uIDAgb2YgY2hpbGQgMCB7 I3RleHR9IG9mIGNoaWxkIDAge0RJVn0gb2YgeyNkb2N1bWVudC1mcmFnbWVudH0gb2YgY2hpbGQg MyB7SU5QVVR9IG9mIGJvZHkKK3NlbGVjdGlvbiBlbmQ6ICAgcG9zaXRpb24gNjEgb2YgY2hpbGQg MCB7I3RleHR9IG9mIGNoaWxkIDAge0RJVn0gb2YgeyNkb2N1bWVudC1mcmFnbWVudH0gb2YgY2hp bGQgMyB7SU5QVVR9IG9mIGJvZHkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2lv cy9UZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL1Rlc3RFeHBlY3Rh dGlvbnMKaW5kZXggMmIzMzI1YjlhMjdlYzVkYTI2ZjBkMDcxYzQ4YjViNDhjMTdiMWFmZi4uMzAy NzUzMWI5YmI4MTJkNzJkODNiYjIzZThhMDViOGM4YTU2ZTlkMCAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vaW9zL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vaW9zL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTEzMzcsNyArMTMzNyw2IEBAIHdlYmtpdC5v cmcvYi8xNzg5NjMgZmFzdC9jc3Mvc3RpY2t5L3N0aWNreS13cml0aW5nLW1vZGUtdmVydGljYWwt bHIuaHRtbCBbIEltYWdlCiB3ZWJraXQub3JnL2IvMTc4OTYzIGZhc3QvY3NzL3N0aWNreS9zdGlj a3ktd3JpdGluZy1tb2RlLXZlcnRpY2FsLXJsLmh0bWwgWyBJbWFnZU9ubHlGYWlsdXJlIF0KIAog IyBlZGl0aW5nL2RlbGV0aW5nIHRlc3RzIHRvIHRyaWFnZQotZWRpdGluZy9kZWxldGluZy9kZWxl dGUtYWxsLXRleHQtaW4tdGV4dC1maWVsZC1hc3NlcnRpb24uaHRtbCBbIEZhaWx1cmUgXQogZWRp dGluZy9kZWxldGluZy9kZWxldGUtY2VsbC1jb250ZW50cy5odG1sIFsgRmFpbHVyZSBdCiBlZGl0 aW5nL2RlbGV0aW5nL3NtYXJ0LWRlbGV0ZS0wMDIuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9k ZWxldGluZy9zbWFydC1kZWxldGUtYWNyb3NzLWVkaXRhYmxlLWJvdW5kYXJpZXMuaHRtbCBbIEZh aWx1cmUgXQpAQCAtMTY4Miw3ICsxNjgxLDYgQEAgZmFzdC9mb3Jtcy9oaWRwaS10ZXh0ZmllbGQt YmFja2dyb3VuZC1ibGVlZGluZy5odG1sIFsgSW1hZ2VPbmx5RmFpbHVyZSBdCiBmYXN0L2Zvcm1z L2lucHV0LWJhc2VsaW5lLmh0bWwgWyBGYWlsdXJlIF0KIGZhc3QvZm9ybXMvaW5wdXQtbGl2ZS1w c2V1ZG8tc2VsZWN0b3JzLmh0bWwgWyBGYWlsdXJlIF0KIGZhc3QvZm9ybXMvaW5wdXQtbm8tcmVu ZGVyZXIuaHRtbCBbIEZhaWx1cmUgXQotZmFzdC9mb3Jtcy9pbnB1dC1zZWxlY3Qtd2Via2l0LXVz ZXItc2VsZWN0LW5vbmUuaHRtbCBbIEZhaWx1cmUgXQogZmFzdC9mb3Jtcy9pbnB1dC1zZXQtY29t cG9zaXRpb24tc2Nyb2xsLmh0bWwgWyBGYWlsdXJlIF0KIGZhc3QvZm9ybXMvaW5wdXQtdGV4dGFy ZWEtcGFkZGluZy1tYXRjaC5odG1sIFsgSW1hZ2VPbmx5RmFpbHVyZSBdCiBmYXN0L2Zvcm1zL2xp c3Rib3gtY2xpcC5odG1sIFsgRmFpbHVyZSBdCkBAIC0xNzA3LDEyICsxNzA1LDEwIEBAIGZhc3Qv Zm9ybXMvc2VsZWN0LWxpdmUtcHNldWRvLXNlbGVjdG9ycy5odG1sIFsgRmFpbHVyZSBdCiBmYXN0 L2Zvcm1zL3NlbGVjdC1vdmVyZmxvdy1zY3JvbGwtaW5oZXJpdGVkLmh0bWwgWyBGYWlsdXJlIF0K IGZhc3QvZm9ybXMvc2VsZWN0LW92ZXJmbG93LXNjcm9sbC5odG1sIFsgRmFpbHVyZSBdCiBmYXN0 L2Zvcm1zL3NlbGVjdC9vcHRpb24tc2VsZWN0aW5nLmh0bWwgWyBGYWlsdXJlIF0KLWZhc3QvZm9y bXMvc2hhZG93LXRyZWUtZXhwb3N1cmUuaHRtbCBbIEZhaWx1cmUgXQogZmFzdC9mb3Jtcy90ZXh0 YXJlYS1pbnB1dC1ldmVudC5odG1sIFsgRmFpbHVyZSBdCiBmYXN0L2Zvcm1zL3RleHRhcmVhLWxp dmUtcHNldWRvLXNlbGVjdG9ycy5odG1sIFsgRmFpbHVyZSBdCiBmYXN0L2Zvcm1zL3RleHRhcmVh LW1ldHJpY3MuaHRtbCBbIEZhaWx1cmUgXQogZmFzdC9mb3Jtcy90ZXh0YXJlYS1wbGFjZWhvbGRl ci13cmFwcGluZy5odG1sIFsgSW1hZ2VPbmx5RmFpbHVyZSBdCi1mYXN0L2Zvcm1zL3RleHRhcmVh LXNldC1kZWZhdWx0dmFsdWUtYWZ0ZXItdmFsdWUuaHRtbCBbIEZhaWx1cmUgXQogZmFzdC9mb3Jt cy90ZXh0ZmllbGQtb3ZlcmZsb3ctYnktdmFsdWUtdXBkYXRlLmh0bWwgWyBGYWlsdXJlIF0KIGZh c3QvZnJhbWVzL2NhbGN1bGF0ZS1maXhlZC5odG1sIFsgRmFpbHVyZSBdCiBmYXN0L2ZyYW1lcy9j YWxjdWxhdGUtb3JkZXIuaHRtbCBbIEZhaWx1cmUgXQpAQCAtMjExNCwxMCArMjExMCw4IEBAIGVk aXRpbmcvcGFzdGVib2FyZC80MjQyMjkzLTEuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0 ZWJvYXJkLzU3ODA2OTctMi5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQvY2xp cGJvYXJkLWN1c3RvbURhdGEuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0ZWJvYXJkL2Nv cHktYmFja3NsYXNoLXdpdGgtZXVjLmh0bWwgWyBGYWlsdXJlIF0KLWVkaXRpbmcvcGFzdGVib2Fy ZC9jb3B5LWluLXBhc3N3b3JkLWZpZWxkLmh0bWwgWyBGYWlsdXJlIF0KIGVkaXRpbmcvcGFzdGVi b2FyZC9jb3B5LWluc2lkZS1oMS1wcmVzZXJ2ZXMtaDEuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGlu Zy9wYXN0ZWJvYXJkL2NvcHktdGV4dC13aXRoLWJhY2tncm91bmRjb2xvci5odG1sIFsgRmFpbHVy ZSBdCi1lZGl0aW5nL3Bhc3RlYm9hcmQvY29weS10d28tcGFzdGVib2FyZC10eXBlcy1ib3RoLXdv cmsuaHRtbCBbIEZhaWx1cmUgXQogd2Via2l0Lm9yZy9iLzE3Nzk2MSBlZGl0aW5nL3Bhc3RlYm9h cmQvZGF0YS10cmFuc2Zlci1pdGVtcy5odG1sIFsgU2tpcCBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQv ZGF0YVRyYW5zZmVyLXNldERhdGEtZ2V0RGF0YS5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bh c3RlYm9hcmQvZGlzcGxheS1ibG9jay1vbi1zcGFucy5odG1sIFsgRmFpbHVyZSBdCkBAIC0yMTI1 LDggKzIxMTksNiBAQCBlZGl0aW5nL3Bhc3RlYm9hcmQvZW1hY3MtY3RybC1rLXdpdGgtbW92ZS5o dG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQvZW1hY3MtY3RybC1rLXktMDAxLmh0 bWwgWyBGYWlsdXJlIF0KIGVkaXRpbmcvcGFzdGVib2FyZC9lbWFjcy1raWxscmluZy1hbHRlcm5h dGluZy1hcHBlbmQtcHJlcGVuZC5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQv ZW1hY3Mta2lsbHJpbmctYmFja3dhcmQtZGVsZXRlLXByZXBlbmQuaHRtbCBbIEZhaWx1cmUgXQot ZWRpdGluZy9wYXN0ZWJvYXJkL2lucHV0LXdpdGgtZGlzcGxheS1ub25lLWRpdi5odG1sIFsgRmFp bHVyZSBdCi1lZGl0aW5nL3Bhc3RlYm9hcmQvaW5wdXQtd2l0aC12aXNpYmlsaXR5LWhpZGRlbi5o dG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQvaW5zZXJ0LWRpdi10ZXh0LWludG8t dGV4dC5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQvbWVyZ2UtZW5kLTMuaHRt bCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0ZWJvYXJkL21lcmdlLWVuZC01Lmh0bWwgWyBGYWls dXJlIF0KQEAgLTIxMzcsMTEgKzIxMjksOCBAQCBlZGl0aW5nL3Bhc3RlYm9hcmQvcGFzdGUtYmVm b3JlLXRhYi1zcGFuLmh0bWwgWyBGYWlsdXJlIF0KIGVkaXRpbmcvcGFzdGVib2FyZC9wYXN0ZS1i bG9ja3F1b3RlLTMuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0ZWJvYXJkL3Bhc3RlLWds b2JhbC1zZWxlY3Rpb24uaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0ZWJvYXJkL3Bhc3Rl LWxpc3QtMDA0Lmh0bWwgWyBGYWlsdXJlIF0KLWVkaXRpbmcvcGFzdGVib2FyZC9wYXN0ZS1wbGFj ZWhvbGRlci1pbnB1dC5odG1sIFsgRmFpbHVyZSBdCi1lZGl0aW5nL3Bhc3RlYm9hcmQvcGFzdGUt cGxhaW50ZXh0LXVzZXItc2VsZWN0LW5vbmUuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0 ZWJvYXJkL3Bhc3RlLXNhbml0aXplLWNyYXNoLTEuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9w YXN0ZWJvYXJkL3Bhc3RlLXNhbml0aXplLWNyYXNoLTIuaHRtbCBbIEZhaWx1cmUgXQotZWRpdGlu Zy9wYXN0ZWJvYXJkL3Bhc3RlLXRleHQtZXZlbnRzLmh0bWwgWyBGYWlsdXJlIF0KIGVkaXRpbmcv cGFzdGVib2FyZC9zbWFydC1wYXN0ZS0wMDEuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0 ZWJvYXJkL3NtYXJ0LXBhc3RlLTAwMi5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9h cmQvc21hcnQtcGFzdGUtMDAzLmh0bWwgWyBGYWlsdXJlIF0KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL3BsYXRmb3JtL2lvcy9lZGl0aW5nL3RleHQtaXRlcmF0b3IvaGlkZGVuLXRleHRhcmVhLXNl bGVjdGlvbi1xdWlyay1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3MvZWRp dGluZy90ZXh0LWl0ZXJhdG9yL2hpZGRlbi10ZXh0YXJlYS1zZWxlY3Rpb24tcXVpcmstZXhwZWN0 ZWQudHh0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBjMmQyNDMyODBhODliZGUzNDhm ZTFmNTk5NWJiYWMyODYxYWFjNTE2Li4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwCi0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy9lZGl0aW5nL3RleHQtaXRlcmF0 b3IvaGlkZGVuLXRleHRhcmVhLXNlbGVjdGlvbi1xdWlyay1leHBlY3RlZC50eHQKKysrIC9kZXYv bnVsbApAQCAtMSwxMSArMCwwIEBACi0KLQotRkFJTCBTZWxlY3RpbmcgaW4gYmFyZWx5IHZpc2li bGUgdGV4dGFyZWEgYXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgInRlc3QgdGV4dCIgYnV0IGdvdCAi IgotUEFTUyBTZWxlY3RpbmcgaW4gYmFyZWx5IHZpc2libGUgZGl2IAotUEFTUyBTZWxlY3Rpbmcg aW4gdGV4dGFyZWEgaGlkZGVuIGJ5IGNvbnRhaW5lciAKLVBBU1MgU2VsZWN0aW5nIGluIGRpdiBo aWRkZW4gYnkgY29udGFpbmVyIAotRkFJTCBTZWxlY3RpbmcgaW4gYWJzb2x1dGUgcG9zaXRpb25l ZCB0ZXh0YXJlYSBoaWRkZW4gYnkgY29udGFpbmVyIGFzc2VydF9lcXVhbHM6IGV4cGVjdGVkICJ0 ZXN0IHRleHQiIGJ1dCBnb3QgIiIKLVBBU1MgU2VsZWN0aW5nIGluIGFic29sdXRlIHBvc2l0aW9u ZWQgZGl2IGhpZGRlbiBieSBjb250YWluZXIgCi1GQUlMIFNlbGVjdGluZyBpbiBhYnNvbHV0ZSBw b3NpdGlvbmVkIHplcm8gY29udGVudCB3aWR0aCB0ZXh0YXJlYSBoaWRkZW4gYnkgY29udGFpbmVy IChxdWlyayBiZWhhdmlvcikgYXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgInRlc3QgdGV4dCIgYnV0 IGdvdCAiIgotUEFTUyBTZWxlY3RpbmcgaW4gYWJzb2x1dGUgcG9zaXRpb25lZCB6ZXJvIGNvbnRl bnQgd2lkdGggZGl2IGhpZGRlbiBieSBjb250YWluZXIgCi0KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL3BsYXRmb3JtL2lvcy9mYXN0L2Zvcm1zL2lucHV0LWFwcGVhcmFuY2UtZm9jdXMtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL2Zhc3QvZm9ybXMvaW5wdXQtYXBwZWFy YW5jZS1mb2N1cy1leHBlY3RlZC50eHQKaW5kZXggMjdhYjIxMWMyY2Q4MmY3ZTFiZjg1NmQwMDU4 OGRkZmU2ZDAxNTg0NC4uZjFiNzQwOGQ0OTU1ZjU5ZjNhODk3MmI0NzM3MmM3OTc5NDJkMzE2NSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL2Zhc3QvZm9ybXMvaW5wdXQtYXBw ZWFyYW5jZS1mb2N1cy1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9z L2Zhc3QvZm9ybXMvaW5wdXQtYXBwZWFyYW5jZS1mb2N1cy1leHBlY3RlZC50eHQKQEAgLTMxLDQg KzMxLDUgQEAgbGF5ZXIgYXQgKDE2MCw0OSkgc2l6ZSAxMjJ4MTQKICAgUmVuZGVyQmxvY2sge0RJ Vn0gYXQgKDYsMykgc2l6ZSAxMjN4MTUKICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkg c2l6ZSA3NHgxNAogICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggNzQ6ICJNeSBUZXh0IEZp ZWxkIDIiCi1jYXJldDogcG9zaXRpb24gMTUgb2YgY2hpbGQgMCB7I3RleHR9IG9mIGNoaWxkIDAg e0RJVn0gb2YgeyNkb2N1bWVudC1mcmFnbWVudH0gb2YgY2hpbGQgMyB7SU5QVVR9IG9mIGNoaWxk IDEge1B9IG9mIGJvZHkKK3NlbGVjdGlvbiBzdGFydDogcG9zaXRpb24gMCBvZiBjaGlsZCAwIHsj dGV4dH0gb2YgY2hpbGQgMCB7RElWfSBvZiB7I2RvY3VtZW50LWZyYWdtZW50fSBvZiBjaGlsZCAz IHtJTlBVVH0gb2YgY2hpbGQgMSB7UH0gb2YgYm9keQorc2VsZWN0aW9uIGVuZDogICBwb3NpdGlv biAxNSBvZiBjaGlsZCAwIHsjdGV4dH0gb2YgY2hpbGQgMCB7RElWfSBvZiB7I2RvY3VtZW50LWZy YWdtZW50fSBvZiBjaGlsZCAzIHtJTlBVVH0gb2YgY2hpbGQgMSB7UH0gb2YgYm9keQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL2Zhc3QvZm9ybXMvaW5wdXQtYXBwZWFyYW5j ZS1yZWFkb25seS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3MvZmFzdC9m b3Jtcy9pbnB1dC1hcHBlYXJhbmNlLXJlYWRvbmx5LWV4cGVjdGVkLnR4dAppbmRleCBhMThlNTRi MTZiMWYyZWM5OTcwODg4NjdiY2E0NDZlZDIxZWIyNmU5Li4zOTYzODc0MTQ2M2NlOWI3YjA0MDlm ZDczMjkzNjQ0ZmM0MjM0NjE2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mv ZmFzdC9mb3Jtcy9pbnB1dC1hcHBlYXJhbmNlLXJlYWRvbmx5LWV4cGVjdGVkLnR4dAorKysgYi9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3MvZmFzdC9mb3Jtcy9pbnB1dC1hcHBlYXJhbmNlLXJlYWRv bmx5LWV4cGVjdGVkLnR4dApAQCAtMTIsNCArMTIsNSBAQCBsYXllciBhdCAoMTcsMzMpIHNpemUg MTIyeDE0CiAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICg2LDMpIHNpemUgMTIzeDE1CiAgICAgUmVu ZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgNjB4MTQKICAgICAgIHRleHQgcnVuIGF0ICgw LDApIHdpZHRoIDYwOiAiVGVzdCBQYXNzZWQiCi1jYXJldDogcG9zaXRpb24gMTEgb2YgY2hpbGQg MCB7I3RleHR9IG9mIGNoaWxkIDAge0RJVn0gb2YgeyNkb2N1bWVudC1mcmFnbWVudH0gb2YgY2hp bGQgMiB7SU5QVVR9IG9mIGJvZHkKK3NlbGVjdGlvbiBzdGFydDogcG9zaXRpb24gMCBvZiBjaGls ZCAwIHsjdGV4dH0gb2YgY2hpbGQgMCB7RElWfSBvZiB7I2RvY3VtZW50LWZyYWdtZW50fSBvZiBj aGlsZCAyIHtJTlBVVH0gb2YgYm9keQorc2VsZWN0aW9uIGVuZDogICBwb3NpdGlvbiAxMSBvZiBj aGlsZCAwIHsjdGV4dH0gb2YgY2hpbGQgMCB7RElWfSBvZiB7I2RvY3VtZW50LWZyYWdtZW50fSBv ZiBjaGlsZCAyIHtJTlBVVH0gb2YgYm9keQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vaW9zL2Zhc3QvZm9ybXMvaW5wdXQtZG91YmxlLWNsaWNrLXNlbGVjdGlvbi1nYXAtYnVnLWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy9mYXN0L2Zvcm1zL2lucHV0LWRv dWJsZS1jbGljay1zZWxlY3Rpb24tZ2FwLWJ1Zy1leHBlY3RlZC50eHQKaW5kZXggMjAwMjA0MjM5 NDc3N2E0YjhmMDE3Y2ZmOTBjM2JmODdiZjI2YmFhYS4uZWFmMTIyYzU0MWFkZmJjM2E1OThiYTMw MWI0NGUzZDJmNTRmMDNhZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL2Zh c3QvZm9ybXMvaW5wdXQtZG91YmxlLWNsaWNrLXNlbGVjdGlvbi1nYXAtYnVnLWV4cGVjdGVkLnR4 dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3MvZmFzdC9mb3Jtcy9pbnB1dC1kb3VibGUt Y2xpY2stc2VsZWN0aW9uLWdhcC1idWctZXhwZWN0ZWQudHh0CkBAIC0yNyw0ICsyNyw1IEBAIGxh eWVyIGF0ICgzOSw0MTEpIHNpemUgMTIyeDE0CiAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICg2LDMp IHNpemUgMTIzeDE1CiAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgMzV4MTQK ICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDM1OiAiZm9vIGJhciIKLWNhcmV0OiBwb3Np dGlvbiA3IG9mIGNoaWxkIDAgeyN0ZXh0fSBvZiBjaGlsZCAwIHtESVZ9IG9mIHsjZG9jdW1lbnQt ZnJhZ21lbnR9IG9mIGNoaWxkIDEge0lOUFVUfSBvZiBjaGlsZCAxIHtURH0gb2YgY2hpbGQgMCB7 VFJ9IG9mIGNoaWxkIDEge1RCT0RZfSBvZiBjaGlsZCAzIHtUQUJMRX0gb2YgYm9keQorc2VsZWN0 aW9uIHN0YXJ0OiBwb3NpdGlvbiAwIG9mIGNoaWxkIDAgeyN0ZXh0fSBvZiBjaGlsZCAwIHtESVZ9 IG9mIHsjZG9jdW1lbnQtZnJhZ21lbnR9IG9mIGNoaWxkIDEge0lOUFVUfSBvZiBjaGlsZCAxIHtU RH0gb2YgY2hpbGQgMCB7VFJ9IG9mIGNoaWxkIDEge1RCT0RZfSBvZiBjaGlsZCAzIHtUQUJMRX0g b2YgYm9keQorc2VsZWN0aW9uIGVuZDogICBwb3NpdGlvbiA3IG9mIGNoaWxkIDAgeyN0ZXh0fSBv ZiBjaGlsZCAwIHtESVZ9IG9mIHsjZG9jdW1lbnQtZnJhZ21lbnR9IG9mIGNoaWxkIDEge0lOUFVU fSBvZiBjaGlsZCAxIHtURH0gb2YgY2hpbGQgMCB7VFJ9IG9mIGNoaWxkIDEge1RCT0RZfSBvZiBj aGlsZCAzIHtUQUJMRX0gb2YgYm9keQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0v aW9zL2Zhc3QvZm9ybXMvdGV4dGZpZWxkLW91dGxpbmUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvcGxhdGZvcm0vaW9zL2Zhc3QvZm9ybXMvdGV4dGZpZWxkLW91dGxpbmUtZXhwZWN0ZWQudHh0 CmluZGV4IDBjNDlhMTM5ZDMyZTg2YTg1ZWU5Yjc4YTljZjM2ZjhjZWEwZjZmYzAuLmIzZjM5Yjkx NjM3NDRkYmU4ZWM4MmYwNjVlYzA1MzBlOWExODJhNDAgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L3BsYXRmb3JtL2lvcy9mYXN0L2Zvcm1zL3RleHRmaWVsZC1vdXRsaW5lLWV4cGVjdGVkLnR4dAor KysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3MvZmFzdC9mb3Jtcy90ZXh0ZmllbGQtb3V0bGlu ZS1leHBlY3RlZC50eHQKQEAgLTEyLDQgKzEyLDUgQEAgbGF5ZXIgYXQgKDIxLDM1KSBzaXplIDIy MngyNSBzY3JvbGxYIDMwMyBzY3JvbGxXaWR0aCA1MjMKICAgUmVuZGVyQmxvY2sge0RJVn0gYXQg KDExLDUpIHNpemUgMjIzeDI1CiAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUg NTIyeDI1CiAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCA1MjI6ICJUaGlzIHRlc3RzIHRo YXQgdHlwaW5nIGRvZXNuJ3QgY3V0IGhvbGVzIGluIHRoZSBmb2N1cyBvdXRsaW5lYSIKLWNhcmV0 OiBwb3NpdGlvbiA2MiBvZiBjaGlsZCAwIHsjdGV4dH0gb2YgY2hpbGQgMCB7RElWfSBvZiB7I2Rv Y3VtZW50LWZyYWdtZW50fSBvZiBjaGlsZCAzIHtJTlBVVH0gb2YgYm9keQorc2VsZWN0aW9uIHN0 YXJ0OiBwb3NpdGlvbiAwIG9mIGNoaWxkIDAgeyN0ZXh0fSBvZiBjaGlsZCAwIHtESVZ9IG9mIHsj ZG9jdW1lbnQtZnJhZ21lbnR9IG9mIGNoaWxkIDMge0lOUFVUfSBvZiBib2R5CitzZWxlY3Rpb24g ZW5kOiAgIHBvc2l0aW9uIDYxIG9mIGNoaWxkIDAgeyN0ZXh0fSBvZiBjaGlsZCAwIHtESVZ9IG9m IHsjZG9jdW1lbnQtZnJhZ21lbnR9IG9mIGNoaWxkIDMge0lOUFVUfSBvZiBib2R5Cg== 360037 2019-01-24 14:22:03 -0800 2019-01-24 15:30:43 -0800 v2 bug-193758-20190124142203.patch text/plain 10392 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjQwMzUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2YyMTE4Yjk1ZDViNTEy Nzk0YzkxY2Q3YWUzYzJmOTBlNjlhOWI2NS4uZGYzNzY4YjE3NGY3OTJiZjVlMjE4ODZmZmMzZDkw MTBlNDVkZTE3MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDE5LTAxLTI0ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJs ZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdo ZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTE5Mzc1OAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNDM2MTQ5 Nzg+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ29k ZU1pcnJvcidzIHNjcmlwdCBhZGRzIGEgcmVwZWF0aW5nIHRpbWVyIHRoYXQgcGVyaW9kaWNhbGx5 IG5vcm1hbGl6ZXMgdGhlIGxvZ2ljYWwgc2VsZWN0aW9uIGluIHRoZSBlZGl0b3IKKyAgICAgICAg KHRoaXMgaXMgZGlzdGluY3QgZnJvbSB0aGUgYWN0dWFsIERPTSBzZWxlY3Rpb24sIHdoaWNoIGlz IGluc2lkZSBhIGhpZGRlbiB0ZXh0YXJlYSBlbGVtZW50KS4gVGhpcyBzY3JpcHQgZGVmaW5lcwor ICAgICAgICBhIGhlbHBlciBtZXRob2QgdG8gc2VsZWN0IGFsbCB0aGUgdGV4dCBpbnNpZGUgb2Yg YSB0ZXh0IGZvcm0gY29udHJvbCwgY2FsbGVkIGBzZWxlY3RJbnB1dGAsIHdoaWNoIG5vcm1hbGx5 CisgICAgICAgIGludm9rZXMgYG5vZGUuc2VsZWN0KClgLiBIb3dldmVyLCBpbiB0aGUgY2FzZSBv ZiBpT1MsIHRoZSBzY3JpcHQgd29ya3MgYXJvdW5kIGJyb2tlbiBgc2VsZWN0KClgIGJlaGF2aW9y IGJ5CisgICAgICAgIHNldHRpbmcgYHNlbGVjdGlvblN0YXJ0YCBhbmQgYHNlbGVjdGlvbkVuZGAg dG8gZW5jb21wYXNzIGFsbCB0aGUgY29udGVudCBpbiB0aGUgZm9ybSBjb250cm9sLiBXaGVuIHJl cXVlc3RpbmcKKyAgICAgICAgdGhlIGRlc2t0b3AgdmVyc2lvbiBvZiB0aGUgc2l0ZSwgQ29kZU1p cnJvciBubyBsb25nZXIgYXR0ZW1wdHMgdG8gYXBwbHkgaXRzIGlPUyB3b3JrYXJvdW5kLgorCisg ICAgICAgIFRoaXMgaU9TLXNwZWNpZmljIGJlaGF2aW9yIHdhcyBpbnRyb2R1Y2VkIHRvIGZpeCA8 cmRhcjovL3Byb2JsZW0vNDkwMTkyMz4uIEhvd2V2ZXIsIHRoZSBvcmlnaW5hbCBidWcgbm8gbG9u Z2VyCisgICAgICAgIHJlcHJvZHVjZXMgZXZlbiB3aXRob3V0IHRoaXMgcXVpcmsuIFRvIGZpeCBD b2RlTWlycm9yLCB3ZSBtYWtlIHR3byBhZGp1c3RtZW50czoKKworICAgICAgICAxLiAgUm9sbCBv dXQgdGhpcyBhbmNpZW50IGRlbW8gaGFjaywgaW4gZmF2b3Igb2Ygc3RhbmRhcmRpemVkIGJlaGF2 aW9yLgorICAgICAgICAyLiAgTm90ZSB0aGF0IGBzZWxlY3QoKWAgaXMgYWxzbyB1c2VkIHdoZW4g Zm9jdXNpbmcgYW4gaW5wdXQuIEhvd2V2ZXIsIHdoZW4gZm9jdXNpbmcgYW4gaW5wdXQgZWxlbWVu dCBvbiBpT1MsIHdlCisgICAgICAgICAgICB3YW50IHRvIG1hdGNoIHRoZSBwbGF0Zm9ybSAoaS5l LiBVSVRleHRGaWVsZCBiZWhhdmlvcikgYW5kIG1vdmUgZm9jdXMgdG8gdGhlIGVuZCBvZiB0aGUg dGV4dCBmaWVsZC4gVG8KKyAgICAgICAgICAgIGFjaGlldmUgdGhpcywgd2UgaW50cm9kdWNlIGEg bmV3IGhlbHBlciBvbiBIVE1MSW5wdXRFbGVtZW50IHRoYXQgaXMgY2FsbGVkIHdoZW4gc2V0dGlu ZyB0aGUgZGVmYXVsdAorICAgICAgICAgICAgc2VsZWN0aW9uIG9mIGEgdGV4dCBpbnB1dCBhZnRl ciBmb2N1czsgb24gaU9TLCB0aGlzIGhlbHBlciBtZXRob2QgbW92ZXMgdGhlIHNlbGVjdGlvbiB0 byB0aGUgZW5kIG9mIHRoZQorICAgICAgICAgICAgaW5wdXQsIGJ1dCBldmVyeXdoZXJlIGVsc2Us IGl0IHNlbGVjdHMgYWxsIHRoZSB0ZXh0IGluIHRoZSBpbnB1dCBlbGVtZW50LgorCisgICAgICAg IFRoaXMgY2F1c2VzIDYgZXhpc3RpbmcgbGF5b3V0IHRlc3RzIHRvIGJlZ2luIHBhc3Npbmcgb24g aU9TLgorCisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZUZvY3VzQXBwZWFyYW5jZSk6CisgICAgICAg IChXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpzZXREZWZhdWx0U2VsZWN0aW9uQWZ0ZXJGb2N1 cyk6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9I VE1MVGV4dEZvcm1Db250cm9sRWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MVGV4 dEZvcm1Db250cm9sRWxlbWVudDo6c2VsZWN0KToKKwogMjAxOS0wMS0yMyAgV2Vuc29uIEhzaWVo ICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBOZWVkIGEgd2F5IGZvciBKYXZh U2NyaXB0IChvciBidW5kbGUpIGNvZGUgdG8gcGFydGljaXBhdGUgaW4gdW5kbwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKaW5kZXggYmNmODljNzc1NWJlNGJkZjBiNTk3 ODI2OWYwZjFhZTdkZTk5MGM3My4uNDNhZTNiNDY2OGExMTYxZDUxOTliOGU0ZWI3YWU1ZGYzZjBm NDJjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC00NTks MTMgKzQ1OSwyNyBAQCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZUZvY3VzQXBwZWFyYW5j ZShTZWxlY3Rpb25SZXN0b3JhdGlvbk1vZGUgcmVzdG9yYXRpbwogewogICAgIGlmIChpc1RleHRG aWVsZCgpKSB7CiAgICAgICAgIGlmIChyZXN0b3JhdGlvbk1vZGUgPT0gU2VsZWN0aW9uUmVzdG9y YXRpb25Nb2RlOjpTZXREZWZhdWx0IHx8ICFoYXNDYWNoZWRTZWxlY3Rpb24oKSkKLSAgICAgICAg ICAgIHNlbGVjdChyZXZlYWxNb2RlLCBFbGVtZW50OjpkZWZhdWx0Rm9jdXNUZXh0U3RhdGVDaGFu Z2VJbnRlbnQoKSk7CisgICAgICAgICAgICBzZXREZWZhdWx0U2VsZWN0aW9uQWZ0ZXJGb2N1cyhy ZXZlYWxNb2RlKTsKICAgICAgICAgZWxzZQogICAgICAgICAgICAgcmVzdG9yZUNhY2hlZFNlbGVj dGlvbihyZXZlYWxNb2RlKTsKICAgICB9IGVsc2UKICAgICAgICAgSFRNTFRleHRGb3JtQ29udHJv bEVsZW1lbnQ6OnVwZGF0ZUZvY3VzQXBwZWFyYW5jZShyZXN0b3JhdGlvbk1vZGUsIHJldmVhbE1v ZGUpOwogfQogCit2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNldERlZmF1bHRTZWxlY3Rpb25BZnRl ckZvY3VzKFNlbGVjdGlvblJldmVhbE1vZGUgcmV2ZWFsTW9kZSkKK3sKKyAgICBBU1NFUlQoaXNU ZXh0RmllbGQoKSk7CisjaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKKyAgICAvLyBXZSBkb24ndCB3 YW50IHRvIHNlbGVjdCBhbGwgdGhlIHRleHQgb24gaU9TIHdoZW4gZm9jdXNpbmcgYSBmaWVsZC4g SW5zdGVhZCwgbWF0Y2ggcGxhdGZvcm0gYmVoYXZpb3IgYnkgZ29pbmcgdG8gdGhlIGVuZCBvZiB0 aGUgbGluZS4KKyAgICBpbnQgc3RhcnQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgp OworICAgIGF1dG8gZGlyZWN0aW9uID0gU2VsZWN0aW9uSGFzRm9yd2FyZERpcmVjdGlvbjsKKyNl bHNlCisgICAgaW50IHN0YXJ0ID0gMDsKKyAgICBhdXRvIGRpcmVjdGlvbiA9IFNlbGVjdGlvbkhh c05vRGlyZWN0aW9uOworI2VuZGlmCisgICAgc2V0U2VsZWN0aW9uUmFuZ2Uoc3RhcnQsIHN0ZDo6 bnVtZXJpY19saW1pdHM8aW50Pjo6bWF4KCksIGRpcmVjdGlvbiwgcmV2ZWFsTW9kZSwgRWxlbWVu dDo6ZGVmYXVsdEZvY3VzVGV4dFN0YXRlQ2hhbmdlSW50ZW50KCkpOworfQorCiB2b2lkIEhUTUxJ bnB1dEVsZW1lbnQ6OmVuZEVkaXRpbmcoKQogewogICAgIGlmICghaXNUZXh0RmllbGQoKSkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oIGIvU291cmNl L1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggYTVlYTcwOWEyOTgyNTRlYjU5 OWU4MzRiZjQ5ZTIxMTY3ZGU2N2U4Ny4uMjgxZjI2NzlhYmVmOWY0Zjk4MWM4MTc0NDY4Yzc1ZWIx ZmVkMTA5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAgLTQ1NCw2 ICs0NTQsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgYWRkVG9SYWRpb0J1dHRvbkdyb3VwKCk7CiAg ICAgdm9pZCByZW1vdmVGcm9tUmFkaW9CdXR0b25Hcm91cCgpOwogCisgICAgdm9pZCBzZXREZWZh dWx0U2VsZWN0aW9uQWZ0ZXJGb2N1cyhTZWxlY3Rpb25SZXZlYWxNb2RlKTsKKwogICAgIEF0b21p Y1N0cmluZyBtX25hbWU7CiAgICAgU3RyaW5nIG1fdmFsdWVJZkRpcnR5OwogICAgIHVuc2lnbmVk IG1fc2l6ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTFRleHRGb3JtQ29u dHJvbEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEZvcm1Db250cm9s RWxlbWVudC5jcHAKaW5kZXggMTViZjI3MTkyZGY3MzA2NTUzMGY4MTJhMDZiMzBjNmY3ODg4YTFl MC4uODEzNjkzM2FkNTU0YzVhMWY3ZTBjNmNhNzg3OWQ5NjVlZmMzZGNhOSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudC5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudC5jcHAKQEAgLTE4 OSwxNCArMTg5LDcgQEAgdm9pZCBIVE1MVGV4dEZvcm1Db250cm9sRWxlbWVudDo6c2V0U2VsZWN0 aW9uRGlyZWN0aW9uKGNvbnN0IFN0cmluZyYgZGlyZWN0aW9uKQogCiB2b2lkIEhUTUxUZXh0Rm9y bUNvbnRyb2xFbGVtZW50OjpzZWxlY3QoU2VsZWN0aW9uUmV2ZWFsTW9kZSByZXZlYWxNb2RlLCBj b25zdCBBWFRleHRTdGF0ZUNoYW5nZUludGVudCYgaW50ZW50KQogewotICAgIC8vIEZJWE1FOiBX ZSBzaG91bGQgYWJzdHJhY3QgdGhlIHNlbGVjdGlvbiBiZWhhdmlvciBpbnRvIGFuIEVkaXRpbmdC ZWhhdmlvciBmdW5jdGlvbiBpbnN0ZWFkCi0gICAgLy8gb2YgaGFyZGNvZGluZyB0aGUgYmVoYXZp b3IgdXNpbmcgYSBtYWNybyBkZWZpbmUuCi0jaWYgUExBVEZPUk0oSU9TX0ZBTUlMWSkKLSAgICAv LyBXZSBkb24ndCB3YW50IHRvIHNlbGVjdCBhbGwgdGhlIHRleHQgb24gaU9TLiBJbnN0ZWFkIHVz ZSB0aGUgc3RhbmRhcmQgdGV4dGZpZWxkIGJlaGF2aW9yIG9mIGdvaW5nIHRvIHRoZSBlbmQgb2Yg dGhlIGxpbmUuCi0gICAgc2V0U2VsZWN0aW9uUmFuZ2Uoc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+ OjptYXgoKSwgc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKSwgU2VsZWN0aW9uSGFzRm9y d2FyZERpcmVjdGlvbiwgcmV2ZWFsTW9kZSwgaW50ZW50KTsKLSNlbHNlCiAgICAgc2V0U2VsZWN0 aW9uUmFuZ2UoMCwgc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKSwgU2VsZWN0aW9uSGFz Tm9EaXJlY3Rpb24sIHJldmVhbE1vZGUsIGludGVudCk7Ci0jZW5kaWYKIH0KIAogU3RyaW5nIEhU TUxUZXh0Rm9ybUNvbnRyb2xFbGVtZW50OjpzZWxlY3RlZFRleHQoKSBjb25zdApkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDNh MjUxZjY3M2Q4MzgwZDhkODI4NTI4YzMzMjk5ZDFlMzQ5ZGIwMmQuLmJlOGVjODJhM2VjYTQ2Yjg4 ZTU5ZjFkZDk2ZjQ3OGY4YWIyYzQ1OGIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxv ZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNyBAQAorMjAxOS0wMS0y NCAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBbaU9T XSBVbmFibGUgdG8gbWFrZSBhIHNlbGVjdGlvbiBpbiBqc2ZpZGRsZS5uZXQgdXNpbmcgYXJyb3cg a2V5cyB3aGVuIHJlcXVlc3RpbmcgZGVza3RvcCBzaXRlCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xOTM3NTgKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVt LzQzNjE0OTc4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1hcmsgc29tZSBleGlzdGluZyBsYXlvdXQgdGVzdHMgYXMgcGFzc2luZyBvbiBpT1MuIEFk ZGl0aW9uYWxseSwgcmVtb3ZlIGZhaWxpbmcgZXhwZWN0YXRpb25zIGZvciBhbm90aGVyCisgICAg ICAgIGV4aXN0aW5nIGxheW91dCB0ZXN0IG9uIGlPUy4KKworICAgICAgICAqIHBsYXRmb3JtL2lv cy9UZXN0RXhwZWN0YXRpb25zOgorICAgICAgICAqIHBsYXRmb3JtL2lvcy9lZGl0aW5nL3RleHQt aXRlcmF0b3IvaGlkZGVuLXRleHRhcmVhLXNlbGVjdGlvbi1xdWlyay1leHBlY3RlZC50eHQ6IFJl bW92ZWQuCisKIDIwMTktMDEtMjMgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5j b20+CiAKICAgICAgICAgTmVlZCBhIHdheSBmb3IgSmF2YVNjcmlwdCAob3IgYnVuZGxlKSBjb2Rl IHRvIHBhcnRpY2lwYXRlIGluIHVuZG8KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3Jt L2lvcy9UZXN0RXhwZWN0YXRpb25zIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zL1Rlc3RFeHBl Y3RhdGlvbnMKaW5kZXggMmIzMzI1YjlhMjdlYzVkYTI2ZjBkMDcxYzQ4YjViNDhjMTdiMWFmZi4u YzhhNjA2ZjZlNzY3Yzg1OWU5ZWM3MTI0MTJjYWI1ZjFhYmFhODY4YSAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vaW9zL1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vaW9zL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTE2ODIsNyArMTY4Miw2IEBAIGZhc3Qv Zm9ybXMvaGlkcGktdGV4dGZpZWxkLWJhY2tncm91bmQtYmxlZWRpbmcuaHRtbCBbIEltYWdlT25s eUZhaWx1cmUgXQogZmFzdC9mb3Jtcy9pbnB1dC1iYXNlbGluZS5odG1sIFsgRmFpbHVyZSBdCiBm YXN0L2Zvcm1zL2lucHV0LWxpdmUtcHNldWRvLXNlbGVjdG9ycy5odG1sIFsgRmFpbHVyZSBdCiBm YXN0L2Zvcm1zL2lucHV0LW5vLXJlbmRlcmVyLmh0bWwgWyBGYWlsdXJlIF0KLWZhc3QvZm9ybXMv aW5wdXQtc2VsZWN0LXdlYmtpdC11c2VyLXNlbGVjdC1ub25lLmh0bWwgWyBGYWlsdXJlIF0KIGZh c3QvZm9ybXMvaW5wdXQtc2V0LWNvbXBvc2l0aW9uLXNjcm9sbC5odG1sIFsgRmFpbHVyZSBdCiBm YXN0L2Zvcm1zL2lucHV0LXRleHRhcmVhLXBhZGRpbmctbWF0Y2guaHRtbCBbIEltYWdlT25seUZh aWx1cmUgXQogZmFzdC9mb3Jtcy9saXN0Ym94LWNsaXAuaHRtbCBbIEZhaWx1cmUgXQpAQCAtMTcw NywxMiArMTcwNiwxMCBAQCBmYXN0L2Zvcm1zL3NlbGVjdC1saXZlLXBzZXVkby1zZWxlY3RvcnMu aHRtbCBbIEZhaWx1cmUgXQogZmFzdC9mb3Jtcy9zZWxlY3Qtb3ZlcmZsb3ctc2Nyb2xsLWluaGVy aXRlZC5odG1sIFsgRmFpbHVyZSBdCiBmYXN0L2Zvcm1zL3NlbGVjdC1vdmVyZmxvdy1zY3JvbGwu aHRtbCBbIEZhaWx1cmUgXQogZmFzdC9mb3Jtcy9zZWxlY3Qvb3B0aW9uLXNlbGVjdGluZy5odG1s IFsgRmFpbHVyZSBdCi1mYXN0L2Zvcm1zL3NoYWRvdy10cmVlLWV4cG9zdXJlLmh0bWwgWyBGYWls dXJlIF0KIGZhc3QvZm9ybXMvdGV4dGFyZWEtaW5wdXQtZXZlbnQuaHRtbCBbIEZhaWx1cmUgXQog ZmFzdC9mb3Jtcy90ZXh0YXJlYS1saXZlLXBzZXVkby1zZWxlY3RvcnMuaHRtbCBbIEZhaWx1cmUg XQogZmFzdC9mb3Jtcy90ZXh0YXJlYS1tZXRyaWNzLmh0bWwgWyBGYWlsdXJlIF0KIGZhc3QvZm9y bXMvdGV4dGFyZWEtcGxhY2Vob2xkZXItd3JhcHBpbmcuaHRtbCBbIEltYWdlT25seUZhaWx1cmUg XQotZmFzdC9mb3Jtcy90ZXh0YXJlYS1zZXQtZGVmYXVsdHZhbHVlLWFmdGVyLXZhbHVlLmh0bWwg WyBGYWlsdXJlIF0KIGZhc3QvZm9ybXMvdGV4dGZpZWxkLW92ZXJmbG93LWJ5LXZhbHVlLXVwZGF0 ZS5odG1sIFsgRmFpbHVyZSBdCiBmYXN0L2ZyYW1lcy9jYWxjdWxhdGUtZml4ZWQuaHRtbCBbIEZh aWx1cmUgXQogZmFzdC9mcmFtZXMvY2FsY3VsYXRlLW9yZGVyLmh0bWwgWyBGYWlsdXJlIF0KQEAg LTIxMTcsNyArMjExNCw2IEBAIGVkaXRpbmcvcGFzdGVib2FyZC9jb3B5LWJhY2tzbGFzaC13aXRo LWV1Yy5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQvY29weS1pbi1wYXNzd29y ZC1maWVsZC5odG1sIFsgRmFpbHVyZSBdCiBlZGl0aW5nL3Bhc3RlYm9hcmQvY29weS1pbnNpZGUt aDEtcHJlc2VydmVzLWgxLmh0bWwgWyBGYWlsdXJlIF0KIGVkaXRpbmcvcGFzdGVib2FyZC9jb3B5 LXRleHQtd2l0aC1iYWNrZ3JvdW5kY29sb3IuaHRtbCBbIEZhaWx1cmUgXQotZWRpdGluZy9wYXN0 ZWJvYXJkL2NvcHktdHdvLXBhc3RlYm9hcmQtdHlwZXMtYm90aC13b3JrLmh0bWwgWyBGYWlsdXJl IF0KIHdlYmtpdC5vcmcvYi8xNzc5NjEgZWRpdGluZy9wYXN0ZWJvYXJkL2RhdGEtdHJhbnNmZXIt aXRlbXMuaHRtbCBbIFNraXAgXQogZWRpdGluZy9wYXN0ZWJvYXJkL2RhdGFUcmFuc2Zlci1zZXRE YXRhLWdldERhdGEuaHRtbCBbIEZhaWx1cmUgXQogZWRpdGluZy9wYXN0ZWJvYXJkL2Rpc3BsYXkt YmxvY2stb24tc3BhbnMuaHRtbCBbIEZhaWx1cmUgXQpAQCAtMjEzNyw3ICsyMTMzLDYgQEAgZWRp dGluZy9wYXN0ZWJvYXJkL3Bhc3RlLWJlZm9yZS10YWItc3Bhbi5odG1sIFsgRmFpbHVyZSBdCiBl ZGl0aW5nL3Bhc3RlYm9hcmQvcGFzdGUtYmxvY2txdW90ZS0zLmh0bWwgWyBGYWlsdXJlIF0KIGVk aXRpbmcvcGFzdGVib2FyZC9wYXN0ZS1nbG9iYWwtc2VsZWN0aW9uLmh0bWwgWyBGYWlsdXJlIF0K IGVkaXRpbmcvcGFzdGVib2FyZC9wYXN0ZS1saXN0LTAwNC5odG1sIFsgRmFpbHVyZSBdCi1lZGl0 aW5nL3Bhc3RlYm9hcmQvcGFzdGUtcGxhY2Vob2xkZXItaW5wdXQuaHRtbCBbIEZhaWx1cmUgXQog ZWRpdGluZy9wYXN0ZWJvYXJkL3Bhc3RlLXBsYWludGV4dC11c2VyLXNlbGVjdC1ub25lLmh0bWwg WyBGYWlsdXJlIF0KIGVkaXRpbmcvcGFzdGVib2FyZC9wYXN0ZS1zYW5pdGl6ZS1jcmFzaC0xLmh0 bWwgWyBGYWlsdXJlIF0KIGVkaXRpbmcvcGFzdGVib2FyZC9wYXN0ZS1zYW5pdGl6ZS1jcmFzaC0y Lmh0bWwgWyBGYWlsdXJlIF0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2lvcy9l ZGl0aW5nL3RleHQtaXRlcmF0b3IvaGlkZGVuLXRleHRhcmVhLXNlbGVjdGlvbi1xdWlyay1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3MvZWRpdGluZy90ZXh0LWl0ZXJhdG9y L2hpZGRlbi10ZXh0YXJlYS1zZWxlY3Rpb24tcXVpcmstZXhwZWN0ZWQudHh0CmRlbGV0ZWQgZmls ZSBtb2RlIDEwMDY0NAppbmRleCBjMmQyNDMyODBhODliZGUzNDhmZTFmNTk5NWJiYWMyODYxYWFj NTE2Li4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL2lvcy9lZGl0aW5nL3RleHQtaXRlcmF0b3IvaGlkZGVuLXRleHRhcmVh LXNlbGVjdGlvbi1xdWlyay1leHBlY3RlZC50eHQKKysrIC9kZXYvbnVsbApAQCAtMSwxMSArMCww IEBACi0KLQotRkFJTCBTZWxlY3RpbmcgaW4gYmFyZWx5IHZpc2libGUgdGV4dGFyZWEgYXNzZXJ0 X2VxdWFsczogZXhwZWN0ZWQgInRlc3QgdGV4dCIgYnV0IGdvdCAiIgotUEFTUyBTZWxlY3Rpbmcg aW4gYmFyZWx5IHZpc2libGUgZGl2IAotUEFTUyBTZWxlY3RpbmcgaW4gdGV4dGFyZWEgaGlkZGVu IGJ5IGNvbnRhaW5lciAKLVBBU1MgU2VsZWN0aW5nIGluIGRpdiBoaWRkZW4gYnkgY29udGFpbmVy IAotRkFJTCBTZWxlY3RpbmcgaW4gYWJzb2x1dGUgcG9zaXRpb25lZCB0ZXh0YXJlYSBoaWRkZW4g YnkgY29udGFpbmVyIGFzc2VydF9lcXVhbHM6IGV4cGVjdGVkICJ0ZXN0IHRleHQiIGJ1dCBnb3Qg IiIKLVBBU1MgU2VsZWN0aW5nIGluIGFic29sdXRlIHBvc2l0aW9uZWQgZGl2IGhpZGRlbiBieSBj b250YWluZXIgCi1GQUlMIFNlbGVjdGluZyBpbiBhYnNvbHV0ZSBwb3NpdGlvbmVkIHplcm8gY29u dGVudCB3aWR0aCB0ZXh0YXJlYSBoaWRkZW4gYnkgY29udGFpbmVyIChxdWlyayBiZWhhdmlvcikg YXNzZXJ0X2VxdWFsczogZXhwZWN0ZWQgInRlc3QgdGV4dCIgYnV0IGdvdCAiIgotUEFTUyBTZWxl Y3RpbmcgaW4gYWJzb2x1dGUgcG9zaXRpb25lZCB6ZXJvIGNvbnRlbnQgd2lkdGggZGl2IGhpZGRl biBieSBjb250YWluZXIgCi0K 361025 2019-02-03 13:12:58 -0800 2019-02-04 16:04:25 -0800 Use EditingBehavior bug-193758-20190203131257.patch text/plain 3109 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjQwOTAxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzRkODVlZDliOTE3OTc1 ZWM3MjQ4NjUzYzExZjdiNjA3ZmVkM2FkMC4uMmJlZWZkMTZjMTVhOTMxZjMxOWNkNzc3NmVhZDNk NWIwZjkwODU0YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE5LTAyLTAzICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJs ZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdo ZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgRm9sbG93dXAgdG8gaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5Mzc1OAorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFB1dCB0aGUgaU9TLXNwZWNpZmljIGJlaGF2 aW9yIGJlaGluZCBhbiBFZGl0aW5nQmVoYXZpb3IgY2hlY2ssIHJhdGhlciB0aGFuIGEgY29tcGls ZS10aW1lIGd1YXJkLiBObyBjaGFuZ2UgaW4KKyAgICAgICAgYmVoYXZpb3IuCisKKyAgICAgICAg KiBlZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oOgorICAgICAgICAoV2ViQ29yZTo6RWRpdGluZ0Jl aGF2aW9yOjpzaG91bGRNb3ZlU2VsZWN0aW9uVG9FbmRXaGVuRm9jdXNpbmdUZXh0SW5wdXQgY29u c3QpOgorICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpIVE1MSW5wdXRFbGVtZW50OjpzZXREZWZhdWx0U2VsZWN0aW9uQWZ0ZXJGb2N1cyk6CisK IDIwMTktMDItMDIgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAg ICAgICAgVW5hYmxlIHRvIG1vdmUgc2VsZWN0aW9uIGludG8gZWRpdGFibGUgcm9vdHMgd2l0aCAw IGhlaWdodApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZp b3IuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmgKaW5kZXggMjdm YjFmMDc2OWRiMDYxMzhiYTM1OTM3OWVkYmYwOWQ3ODJkYzhiMy4uNjU1YzRlZGFhNmMyYzQzNmU0 OTk4MTgyNWYzZjAyMjZhNzAwOTNlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9FZGl0aW5nQmVoYXZpb3IuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0VkaXRpbmdC ZWhhdmlvci5oCkBAIC05Myw2ICs5Myw5IEBAIHB1YmxpYzoKICAgICAvLyBMaW51eCBhbmQgV2lu ZG93cyBhbHdheXMgZXh0ZW5kIHNlbGVjdGlvbnMgZnJvbSB0aGUgZXh0ZW50IGVuZHBvaW50Lgog ICAgIGJvb2wgc2hvdWxkQWx3YXlzRXh0ZW5kU2VsZWN0aW9uRnJvbUV4dGVudEVuZHBvaW50KCkg Y29uc3QgeyByZXR1cm4gbV90eXBlICE9IEVkaXRpbmdNYWNCZWhhdmlvciAmJiBtX3R5cGUgIT0g RWRpdGluZ0lPU0JlaGF2aW9yOyB9CiAKKyAgICAvLyBPbiBpT1MsIHdlIGRvbid0IHdhbnQgdG8g c2VsZWN0IGFsbCB0aGUgdGV4dCB3aGVuIGZvY3VzaW5nIGEgZmllbGQuIEluc3RlYWQsIG1hdGNo IHBsYXRmb3JtIGJlaGF2aW9yIGJ5IGdvaW5nIHRvIHRoZSBlbmQgb2YgdGhlIGxpbmUuCisgICAg Ym9vbCBzaG91bGRNb3ZlU2VsZWN0aW9uVG9FbmRXaGVuRm9jdXNpbmdUZXh0SW5wdXQoKSBjb25z dCB7IHJldHVybiBtX3R5cGUgPT0gRWRpdGluZ0lPU0JlaGF2aW9yOyB9CisKIHByaXZhdGU6CiAg ICAgRWRpdGluZ0JlaGF2aW9yVHlwZSBtX3R5cGU7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TElucHV0RWxlbWVudC5jcHAKaW5kZXggNDNhZTNiNDY2OGExMTYxZDUxOTliOGU0ZWI3YWU1ZGYz ZjBmNDJjMC4uZWMyMzk4YzBlMzQ2ZmQzMmM5M2M4NGVmNzY2MjEyM2E5ZjkzZDFkYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC00NjksMTQgKzQ2OSwxMyBA QCB2b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnVwZGF0ZUZvY3VzQXBwZWFyYW5jZShTZWxlY3Rpb25S ZXN0b3JhdGlvbk1vZGUgcmVzdG9yYXRpbwogdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpzZXREZWZh dWx0U2VsZWN0aW9uQWZ0ZXJGb2N1cyhTZWxlY3Rpb25SZXZlYWxNb2RlIHJldmVhbE1vZGUpCiB7 CiAgICAgQVNTRVJUKGlzVGV4dEZpZWxkKCkpOwotI2lmIFBMQVRGT1JNKElPU19GQU1JTFkpCi0g ICAgLy8gV2UgZG9uJ3Qgd2FudCB0byBzZWxlY3QgYWxsIHRoZSB0ZXh0IG9uIGlPUyB3aGVuIGZv Y3VzaW5nIGEgZmllbGQuIEluc3RlYWQsIG1hdGNoIHBsYXRmb3JtIGJlaGF2aW9yIGJ5IGdvaW5n IHRvIHRoZSBlbmQgb2YgdGhlIGxpbmUuCi0gICAgaW50IHN0YXJ0ID0gc3RkOjpudW1lcmljX2xp bWl0czxpbnQ+OjptYXgoKTsKLSAgICBhdXRvIGRpcmVjdGlvbiA9IFNlbGVjdGlvbkhhc0Zvcndh cmREaXJlY3Rpb247Ci0jZWxzZQogICAgIGludCBzdGFydCA9IDA7CiAgICAgYXV0byBkaXJlY3Rp b24gPSBTZWxlY3Rpb25IYXNOb0RpcmVjdGlvbjsKLSNlbmRpZgorICAgIGF1dG8gZnJhbWUgPSBt YWtlUmVmUHRyKGRvY3VtZW50KCkuZnJhbWUoKSk7CisgICAgaWYgKGZyYW1lICYmIGZyYW1lLT5l ZGl0b3IoKS5iZWhhdmlvcigpLnNob3VsZE1vdmVTZWxlY3Rpb25Ub0VuZFdoZW5Gb2N1c2luZ1Rl eHRJbnB1dCgpKSB7CisgICAgICAgIHN0YXJ0ID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+Ojpt YXgoKTsKKyAgICAgICAgZGlyZWN0aW9uID0gU2VsZWN0aW9uSGFzRm9yd2FyZERpcmVjdGlvbjsK KyAgICB9CiAgICAgc2V0U2VsZWN0aW9uUmFuZ2Uoc3RhcnQsIHN0ZDo6bnVtZXJpY19saW1pdHM8 aW50Pjo6bWF4KCksIGRpcmVjdGlvbiwgcmV2ZWFsTW9kZSwgRWxlbWVudDo6ZGVmYXVsdEZvY3Vz VGV4dFN0YXRlQ2hhbmdlSW50ZW50KCkpOwogfQogCg== 361054 2019-02-04 07:33:53 -0800 2019-02-04 16:04:31 -0800 Patch for landing bug-193758-20190204073352.patch text/plain 3081 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjQwOTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOTgxMjhjZGNkMWE4ODQx OTVmZTI5ZWRkYjRjNTIxZDU4NzBhZWUyNi4uNDQxNTM2NjVmMTcxMzJmYzFiMjU2ZjIwNGNmNjZk Yzc5OGJmMTY2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE5LTAyLTA0ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJs ZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdo ZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgRm9sbG93dXAgdG8gaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5Mzc1OAorCisgICAgICAgIFJldmlld2Vk IGJ5IERhbmllbCBCYXRlcy4KKworICAgICAgICBQdXQgdGhlIGlPUy1zcGVjaWZpYyBiZWhhdmlv ciBiZWhpbmQgYW4gRWRpdGluZ0JlaGF2aW9yIGNoZWNrLCByYXRoZXIgdGhhbiBhIGNvbXBpbGUt dGltZSBndWFyZC4gTm8gY2hhbmdlIGluCisgICAgICAgIGJlaGF2aW9yLgorCisgICAgICAgICog ZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRpbmdCZWhh dmlvcjo6c2hvdWxkTW92ZVNlbGVjdGlvblRvRW5kV2hlbkZvY3VzaW5nVGV4dElucHV0IGNvbnN0 KToKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SFRNTElucHV0RWxlbWVudDo6c2V0RGVmYXVsdFNlbGVjdGlvbkFmdGVyRm9jdXMpOgorCiAy MDE5LTAyLTAzICBBbnR0aSBLb2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBE b24ndCBpbmNsdWRlIFNjcm9sbENvb3JkaW5hdG9yLmggZnJvbSBFbGVtZW50LmgKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9yLmggYi9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0VkaXRpbmdCZWhhdmlvci5oCmluZGV4IDI3ZmIxZjA3NjlkYjA2MTM4YmEz NTkzNzllZGJmMDlkNzgyZGM4YjMuLjY1NWM0ZWRhYTZjMmM0MzZlNDk5ODE4MjVmM2YwMjI2YTcw MDkzZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRWRpdGluZ0JlaGF2aW9y LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9FZGl0aW5nQmVoYXZpb3IuaApAQCAtOTMs NiArOTMsOSBAQCBwdWJsaWM6CiAgICAgLy8gTGludXggYW5kIFdpbmRvd3MgYWx3YXlzIGV4dGVu ZCBzZWxlY3Rpb25zIGZyb20gdGhlIGV4dGVudCBlbmRwb2ludC4KICAgICBib29sIHNob3VsZEFs d2F5c0V4dGVuZFNlbGVjdGlvbkZyb21FeHRlbnRFbmRwb2ludCgpIGNvbnN0IHsgcmV0dXJuIG1f dHlwZSAhPSBFZGl0aW5nTWFjQmVoYXZpb3IgJiYgbV90eXBlICE9IEVkaXRpbmdJT1NCZWhhdmlv cjsgfQogCisgICAgLy8gT24gaU9TLCB3ZSBkb24ndCB3YW50IHRvIHNlbGVjdCBhbGwgdGhlIHRl eHQgd2hlbiBmb2N1c2luZyBhIGZpZWxkLiBJbnN0ZWFkLCBtYXRjaCBwbGF0Zm9ybSBiZWhhdmlv ciBieSBnb2luZyB0byB0aGUgZW5kIG9mIHRoZSBsaW5lLgorICAgIGJvb2wgc2hvdWxkTW92ZVNl bGVjdGlvblRvRW5kV2hlbkZvY3VzaW5nVGV4dElucHV0KCkgY29uc3QgeyByZXR1cm4gbV90eXBl ID09IEVkaXRpbmdJT1NCZWhhdmlvcjsgfQorCiBwcml2YXRlOgogICAgIEVkaXRpbmdCZWhhdmlv clR5cGUgbV90eXBlOwogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3Bw CmluZGV4IDQzYWUzYjQ2NjhhMTE2MWQ1MTk5YjhlNGViN2FlNWRmM2YwZjQyYzAuLmNhZmQyZGQy NjllMzEzYjQ2NmYwYThiODc4ZDNmYTRlMmMzYWYwZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcApAQCAtNDY5LDE0ICs0NjksMTMgQEAgdm9pZCBIVE1MSW5wdXRF bGVtZW50Ojp1cGRhdGVGb2N1c0FwcGVhcmFuY2UoU2VsZWN0aW9uUmVzdG9yYXRpb25Nb2RlIHJl c3RvcmF0aW8KIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c2V0RGVmYXVsdFNlbGVjdGlvbkFmdGVy Rm9jdXMoU2VsZWN0aW9uUmV2ZWFsTW9kZSByZXZlYWxNb2RlKQogewogICAgIEFTU0VSVChpc1Rl eHRGaWVsZCgpKTsKLSNpZiBQTEFURk9STShJT1NfRkFNSUxZKQotICAgIC8vIFdlIGRvbid0IHdh bnQgdG8gc2VsZWN0IGFsbCB0aGUgdGV4dCBvbiBpT1Mgd2hlbiBmb2N1c2luZyBhIGZpZWxkLiBJ bnN0ZWFkLCBtYXRjaCBwbGF0Zm9ybSBiZWhhdmlvciBieSBnb2luZyB0byB0aGUgZW5kIG9mIHRo ZSBsaW5lLgotICAgIGludCBzdGFydCA9IHN0ZDo6bnVtZXJpY19saW1pdHM8aW50Pjo6bWF4KCk7 Ci0gICAgYXV0byBkaXJlY3Rpb24gPSBTZWxlY3Rpb25IYXNGb3J3YXJkRGlyZWN0aW9uOwotI2Vs c2UKICAgICBpbnQgc3RhcnQgPSAwOwogICAgIGF1dG8gZGlyZWN0aW9uID0gU2VsZWN0aW9uSGFz Tm9EaXJlY3Rpb247Ci0jZW5kaWYKKyAgICBhdXRvKiBmcmFtZSA9IGRvY3VtZW50KCkuZnJhbWUo KTsKKyAgICBpZiAoZnJhbWUgJiYgZnJhbWUtPmVkaXRvcigpLmJlaGF2aW9yKCkuc2hvdWxkTW92 ZVNlbGVjdGlvblRvRW5kV2hlbkZvY3VzaW5nVGV4dElucHV0KCkpIHsKKyAgICAgICAgc3RhcnQg PSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpOworICAgICAgICBkaXJlY3Rpb24gPSBT ZWxlY3Rpb25IYXNGb3J3YXJkRGlyZWN0aW9uOworICAgIH0KICAgICBzZXRTZWxlY3Rpb25SYW5n ZShzdGFydCwgc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKSwgZGlyZWN0aW9uLCByZXZl YWxNb2RlLCBFbGVtZW50OjpkZWZhdWx0Rm9jdXNUZXh0U3RhdGVDaGFuZ2VJbnRlbnQoKSk7CiB9 CiAK 361112 2019-02-04 15:41:52 -0800 2019-02-04 15:59:40 -0800 Patch bug-193758-20190204154151.patch text/plain 3531 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjQwOTI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWQ4OTcxNGNlMTdhMzUy N2UxMjI4ZDBhYzU3NzlhZDVkODBjZDFiZC4uODRkM2Y2ZWUwNzRkMzc3YmVhZDE0MGMwOTdhNzFm YmM2NTYyYWNjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE5LTAyLTA0ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJs ZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdo ZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgRm9sbG93dXAgdG8gaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5Mzc1OAorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhbiBFZGl0aW5nQmVoYXZpb3IgZ2V0 dGVyIG9uIERvY3VtZW50IHNvIHRoYXQgZWxlbWVudHMgZG9uJ3QgbmVlZCB0byByZWFjaCBvdmVy IHRvIEZyYW1lJ3MgZWRpdG9yIGluIG9yZGVyCisgICAgICAgIHRvIGFzayBhYm91dCBlZGl0aW5n IGJlaGF2aW9ycy4KKworICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEb2N1bWVudDo6ZWRpdGluZ0JlaGF2aW9yIGNvbnN0KToKKyAgICAgICAgKiBkb20vRG9j dW1lbnQuaDoKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6c2V0RGVmYXVsdFNlbGVjdGlvbkFmdGVyRm9jdXMp OgorCiAyMDE5LTAyLTA0ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgog CiAgICAgICAgIFtpT1NdIFVuYWJsZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5l dCB1c2luZyBhcnJvdyBrZXlzIHdoZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20v RG9jdW1lbnQuY3BwCmluZGV4IDUwYmNjZWZjZGU0NzE5NzdjZTliZjQzMWUzMTAxMDRhODA5Yjll MmEuLjJlNDMzZmUzMDdhNjZjNjYxMjZjMWU5NWIwYjA4MmFmYmVjM2Q4MWIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcApAQCAtNjMsNiArNjMsNyBAQAogI2luY2x1ZGUgIkRvY3VtZW50VGltZWxp bmUuaCIKICNpbmNsdWRlICJEb2N1bWVudFR5cGUuaCIKICNpbmNsdWRlICJFZGl0aW5nLmgiCisj aW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yLmgiCiAjaW5jbHVkZSAiRWRpdG9yLmgiCiAjaW5jbHVk ZSAiRWxlbWVudEl0ZXJhdG9yLmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCkBAIC04NzEx LDQgKzg3MTIsOSBAQCB2b2lkIERvY3VtZW50Ojp1cGRhdGVUb3VjaEFjdGlvbkVsZW1lbnRzKEVs ZW1lbnQmIGVsZW1lbnQsIGNvbnN0IFJlbmRlclN0eWxlJiBzdAogfQogI2VuZGlmCiAKKyAgICBF ZGl0aW5nQmVoYXZpb3IgRG9jdW1lbnQ6OmVkaXRpbmdCZWhhdmlvcigpIGNvbnN0CisgICAgewor ICAgICAgICByZXR1cm4gRWRpdGluZ0JlaGF2aW9yKHNldHRpbmdzKCkuZWRpdGluZ0JlaGF2aW9y VHlwZSgpKTsKKyAgICB9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50 LmgKaW5kZXggOGUyODc4ZjRkMTVhYjg1MTUwNjdhM2FhNWRhM2YyNTczMTEwMmQwMy4uNmJjMzhh NTdhMTI5Mjc5Yzk5ZmE3MDIzOTY0NTUwODdmMTY4ZDcyNyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZG9tL0RvY3VtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmgK QEAgLTExMyw2ICsxMTMsNyBAQCBjbGFzcyBEb2N1bWVudFBhcnNlcjsKIGNsYXNzIERvY3VtZW50 U2hhcmVkT2JqZWN0UG9vbDsKIGNsYXNzIERvY3VtZW50VGltZWxpbmU7CiBjbGFzcyBEb2N1bWVu dFR5cGU7CitjbGFzcyBFZGl0aW5nQmVoYXZpb3I7CiBjbGFzcyBFeHRlbnNpb25TdHlsZVNoZWV0 czsKIGNsYXNzIEZsb2F0UXVhZDsKIGNsYXNzIEZsb2F0UmVjdDsKQEAgLTE1NTAsNiArMTU1MSw4 IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldEFsd2F5c0FsbG93TG9jYWxXZWJhcmNoaXZlKCkgeyBt X2Fsd2F5c0FsbG93TG9jYWxXZWJhcmNoaXZlID0gdHJ1ZTsgfQogICAgIGJvb2wgYWx3YXlzQWxs b3dMb2NhbFdlYmFyY2hpdmUoKSBjb25zdCB7IHJldHVybiBtX2Fsd2F5c0FsbG93TG9jYWxXZWJh cmNoaXZlOyB9CiAKKyAgICBFZGl0aW5nQmVoYXZpb3IgZWRpdGluZ0JlaGF2aW9yKCkgY29uc3Q7 CisKIHByb3RlY3RlZDoKICAgICBlbnVtIENvbnN0cnVjdGlvbkZsYWdzIHsgU3ludGhlc2l6ZWQg PSAxLCBOb25SZW5kZXJlZFBsYWNlaG9sZGVyID0gMSA8PCAxIH07CiAgICAgRG9jdW1lbnQoRnJh bWUqLCBjb25zdCBVUkwmLCB1bnNpZ25lZCA9IERlZmF1bHREb2N1bWVudENsYXNzLCB1bnNpZ25l ZCBjb25zdHJ1Y3Rpb25GbGFncyA9IDApOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxl bWVudC5jcHAKaW5kZXggY2FmZDJkZDI2OWUzMTNiNDY2ZjBhOGI4NzhkM2ZhNGUyYzNhZjBmOS4u MjQ5MDY5OGUyMjE3ZGMxMGU1NmExMDMxNWQ4MjI5NGUxNmE2MWNlMCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC00NzEsOCArNDcxLDcgQEAgdm9pZCBIVE1M SW5wdXRFbGVtZW50OjpzZXREZWZhdWx0U2VsZWN0aW9uQWZ0ZXJGb2N1cyhTZWxlY3Rpb25SZXZl YWxNb2RlIHJldmVhbE0KICAgICBBU1NFUlQoaXNUZXh0RmllbGQoKSk7CiAgICAgaW50IHN0YXJ0 ID0gMDsKICAgICBhdXRvIGRpcmVjdGlvbiA9IFNlbGVjdGlvbkhhc05vRGlyZWN0aW9uOwotICAg IGF1dG8qIGZyYW1lID0gZG9jdW1lbnQoKS5mcmFtZSgpOwotICAgIGlmIChmcmFtZSAmJiBmcmFt ZS0+ZWRpdG9yKCkuYmVoYXZpb3IoKS5zaG91bGRNb3ZlU2VsZWN0aW9uVG9FbmRXaGVuRm9jdXNp bmdUZXh0SW5wdXQoKSkgeworICAgIGlmIChkb2N1bWVudCgpLnNldHRpbmdzKCkuZWRpdGluZ0Jl aGF2aW9yKCkuc2hvdWxkTW92ZVNlbGVjdGlvblRvRW5kV2hlbkZvY3VzaW5nVGV4dElucHV0KCkp IHsKICAgICAgICAgc3RhcnQgPSBzdGQ6Om51bWVyaWNfbGltaXRzPGludD46Om1heCgpOwogICAg ICAgICBkaXJlY3Rpb24gPSBTZWxlY3Rpb25IYXNGb3J3YXJkRGlyZWN0aW9uOwogICAgIH0K 361117 2019-02-04 16:04:15 -0800 2019-02-04 16:04:15 -0800 Patch bug-193758-20190204160414.patch text/plain 3706 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjQwOTI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWQ4OTcxNGNlMTdhMzUy N2UxMjI4ZDBhYzU3NzlhZDVkODBjZDFiZC4uODRkM2Y2ZWUwNzRkMzc3YmVhZDE0MGMwOTdhNzFm YmM2NTYyYWNjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE5LTAyLTA0ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFVuYWJs ZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5ldCB1c2luZyBhcnJvdyBrZXlzIHdo ZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKKyAgICAgICAgRm9sbG93dXAgdG8gaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE5Mzc1OAorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhbiBFZGl0aW5nQmVoYXZpb3IgZ2V0 dGVyIG9uIERvY3VtZW50IHNvIHRoYXQgZWxlbWVudHMgZG9uJ3QgbmVlZCB0byByZWFjaCBvdmVy IHRvIEZyYW1lJ3MgZWRpdG9yIGluIG9yZGVyCisgICAgICAgIHRvIGFzayBhYm91dCBlZGl0aW5n IGJlaGF2aW9ycy4KKworICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEb2N1bWVudDo6ZWRpdGluZ0JlaGF2aW9yIGNvbnN0KToKKyAgICAgICAgKiBkb20vRG9j dW1lbnQuaDoKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6c2V0RGVmYXVsdFNlbGVjdGlvbkFmdGVyRm9jdXMp OgorCiAyMDE5LTAyLTA0ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgog CiAgICAgICAgIFtpT1NdIFVuYWJsZSB0byBtYWtlIGEgc2VsZWN0aW9uIGluIGpzZmlkZGxlLm5l dCB1c2luZyBhcnJvdyBrZXlzIHdoZW4gcmVxdWVzdGluZyBkZXNrdG9wIHNpdGUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20v RG9jdW1lbnQuY3BwCmluZGV4IDUwYmNjZWZjZGU0NzE5NzdjZTliZjQzMWUzMTAxMDRhODA5Yjll MmEuLmQ5OGI3MzM1NTk4ODhhMDdiMzYyOWE4YTcyYTYxMmQwNmFlMzk3NTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcApAQCAtNjMsNiArNjMsNyBAQAogI2luY2x1ZGUgIkRvY3VtZW50VGltZWxp bmUuaCIKICNpbmNsdWRlICJEb2N1bWVudFR5cGUuaCIKICNpbmNsdWRlICJFZGl0aW5nLmgiCisj aW5jbHVkZSAiRWRpdGluZ0JlaGF2aW9yLmgiCiAjaW5jbHVkZSAiRWRpdG9yLmgiCiAjaW5jbHVk ZSAiRWxlbWVudEl0ZXJhdG9yLmgiCiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCkBAIC04NzEx LDQgKzg3MTIsOSBAQCB2b2lkIERvY3VtZW50Ojp1cGRhdGVUb3VjaEFjdGlvbkVsZW1lbnRzKEVs ZW1lbnQmIGVsZW1lbnQsIGNvbnN0IFJlbmRlclN0eWxlJiBzdAogfQogI2VuZGlmCiAKK0VkaXRp bmdCZWhhdmlvciBEb2N1bWVudDo6ZWRpdGluZ0JlaGF2aW9yKCkgY29uc3QKK3sKKyAgICByZXR1 cm4gRWRpdGluZ0JlaGF2aW9yKHNldHRpbmdzKCkuZWRpdGluZ0JlaGF2aW9yVHlwZSgpKTsKK30K KwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9t L0RvY3VtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAppbmRleCA4ZTI4Nzhm NGQxNWFiODUxNTA2N2EzYWE1ZGEzZjI1NzMxMTAyZDAzLi42YmMzOGE1N2ExMjkyNzljOTlmYTcw MjM5NjQ1NTA4N2YxNjhkNzI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1l bnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaApAQCAtMTEzLDYgKzExMyw3 IEBAIGNsYXNzIERvY3VtZW50UGFyc2VyOwogY2xhc3MgRG9jdW1lbnRTaGFyZWRPYmplY3RQb29s OwogY2xhc3MgRG9jdW1lbnRUaW1lbGluZTsKIGNsYXNzIERvY3VtZW50VHlwZTsKK2NsYXNzIEVk aXRpbmdCZWhhdmlvcjsKIGNsYXNzIEV4dGVuc2lvblN0eWxlU2hlZXRzOwogY2xhc3MgRmxvYXRR dWFkOwogY2xhc3MgRmxvYXRSZWN0OwpAQCAtMTU1MCw2ICsxNTUxLDggQEAgcHVibGljOgogICAg IHZvaWQgc2V0QWx3YXlzQWxsb3dMb2NhbFdlYmFyY2hpdmUoKSB7IG1fYWx3YXlzQWxsb3dMb2Nh bFdlYmFyY2hpdmUgPSB0cnVlOyB9CiAgICAgYm9vbCBhbHdheXNBbGxvd0xvY2FsV2ViYXJjaGl2 ZSgpIGNvbnN0IHsgcmV0dXJuIG1fYWx3YXlzQWxsb3dMb2NhbFdlYmFyY2hpdmU7IH0KIAorICAg IEVkaXRpbmdCZWhhdmlvciBlZGl0aW5nQmVoYXZpb3IoKSBjb25zdDsKKwogcHJvdGVjdGVkOgog ICAgIGVudW0gQ29uc3RydWN0aW9uRmxhZ3MgeyBTeW50aGVzaXplZCA9IDEsIE5vblJlbmRlcmVk UGxhY2Vob2xkZXIgPSAxIDw8IDEgfTsKICAgICBEb2N1bWVudChGcmFtZSosIGNvbnN0IFVSTCYs IHVuc2lnbmVkID0gRGVmYXVsdERvY3VtZW50Q2xhc3MsIHVuc2lnbmVkIGNvbnN0cnVjdGlvbkZs YWdzID0gMCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1l bnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAppbmRleCBj YWZkMmRkMjY5ZTMxM2I0NjZmMGE4Yjg3OGQzZmE0ZTJjM2FmMGY5Li5lNWVjNWM5ODQzODkyNDc5 MzA5NDJmMmMxN2E5ZjU5ZjNkNDM4MDFlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxJbnB1dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0 RWxlbWVudC5jcHAKQEAgLTM4LDYgKzM4LDcgQEAKICNpbmNsdWRlICJDaHJvbWVDbGllbnQuaCIK ICNpbmNsdWRlICJEYXRlVGltZUNob29zZXIuaCIKICNpbmNsdWRlICJEb2N1bWVudC5oIgorI2lu Y2x1ZGUgIkVkaXRpbmdCZWhhdmlvci5oIgogI2luY2x1ZGUgIkVkaXRvci5oIgogI2luY2x1ZGUg IkV2ZW50TmFtZXMuaCIKICNpbmNsdWRlICJGaWxlSW5wdXRUeXBlLmgiCkBAIC00NzEsOCArNDcy LDcgQEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpzZXREZWZhdWx0U2VsZWN0aW9uQWZ0ZXJGb2N1 cyhTZWxlY3Rpb25SZXZlYWxNb2RlIHJldmVhbE0KICAgICBBU1NFUlQoaXNUZXh0RmllbGQoKSk7 CiAgICAgaW50IHN0YXJ0ID0gMDsKICAgICBhdXRvIGRpcmVjdGlvbiA9IFNlbGVjdGlvbkhhc05v RGlyZWN0aW9uOwotICAgIGF1dG8qIGZyYW1lID0gZG9jdW1lbnQoKS5mcmFtZSgpOwotICAgIGlm IChmcmFtZSAmJiBmcmFtZS0+ZWRpdG9yKCkuYmVoYXZpb3IoKS5zaG91bGRNb3ZlU2VsZWN0aW9u VG9FbmRXaGVuRm9jdXNpbmdUZXh0SW5wdXQoKSkgeworICAgIGlmIChkb2N1bWVudCgpLmVkaXRp bmdCZWhhdmlvcigpLnNob3VsZE1vdmVTZWxlY3Rpb25Ub0VuZFdoZW5Gb2N1c2luZ1RleHRJbnB1 dCgpKSB7CiAgICAgICAgIHN0YXJ0ID0gc3RkOjpudW1lcmljX2xpbWl0czxpbnQ+OjptYXgoKTsK ICAgICAgICAgZGlyZWN0aW9uID0gU2VsZWN0aW9uSGFzRm9yd2FyZERpcmVjdGlvbjsKICAgICB9 Cg==