88028 2012-05-31 17:25:14 -0700 [chromium] Provide access to the WebPlugin created by the helper plugin widget 2012-06-11 11:14:40 -0700 1 1 1 Unclassified WebKit Media 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 87399 1 ddorwin ddorwin abarth dglazkov eric.carlson feature-media-reviews fishd jamesr tkent tkent+wkapi webkit.review.bot oldest_to_newest 638834 0 ddorwin 2012-05-31 17:25:14 -0700 While bug 87399 enables instantiation of a plugin, the embedder cannot (directly) communicate with that plugin instance. Therefore, we need to extend the the functionality in that issue to provide access to the WebPlugin instance that is created when the helper plugin widget is created. 638844 1 145180 ddorwin 2012-05-31 17:41:14 -0700 Created attachment 145180 Patch for initial feedback 638851 2 ddorwin 2012-05-31 17:52:30 -0700 This initial patch demonstrates that we can get the WebPlugin pointer, but I'd prefer a more elegant solution. My initial idea was to decorate the WebFrameClient passed to WebHelperPluginImpl::initializeFrame() such that the createPlugin() call could be intercepted. The problem is that WebFrameClient is a large interface and, more importantly, has default implementations for all functions. As a result, the decorator could easily be missing a forwarding method without anyone noticing. Suggestions welcome! 638897 3 ddorwin 2012-05-31 19:06:18 -0700 One option would be to create an EmptyWebFrameClient or BaseWebFrameClient class that has all the default implementations and have RenderViewImpl and the test classes inherit from it. The decorator class would inherit from WebFrameClient. This would allow us to continue making Changes to WebKit before the corresponding Chromium changes while still forcing any changes to WebFrameClient to be accounted for in the decorator. Reviewers, WDYT? I'm going to wait for feedback before I spend time implementing this large decorator. 638970 4 145180 abarth 2012-05-31 22:08:09 -0700 Comment on attachment 145180 Patch for initial feedback View in context: https://bugs.webkit.org/attachment.cgi?id=145180&action=review > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:122 > + WebPlugin* m_plugin; I feel a bit lost in the trees reading this patch. What keeps m_plugin align? I would have expected us to have something like a RefPtr to the plugin here. 639515 5 145180 ddorwin 2012-06-01 10:48:21 -0700 Comment on attachment 145180 Patch for initial feedback View in context: https://bugs.webkit.org/attachment.cgi?id=145180&action=review >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:122 >> + WebPlugin* m_plugin; > > I feel a bit lost in the trees reading this patch. What keeps m_plugin align? I would have expected us to have something like a RefPtr to the plugin here. s/align/alive/ ? WebPlugin is not RefCounted currently. The lifetime should be fine because the WebPlugin should exist as long as the element exists, and the element will exist as long as the WebHelperPluginImpl widget exists. That said, I would prefer a better guarantee. FWIW, this pointer gets returned to the embedder code, and in the Chrome case, it is just used to obtain a PluginInstance, which is refcounted. See the code in the next comment on this bug. In the current implementation, m_plugin is just a place to temporarily store data from a "callback" before it gets returned up the stack. All of this happens within WebMediaPlayerClientImpl::createHelperPlugin() and its callees. We could actually move it down into WebViewImpl::createHelperPlugin(). With this knowledge, one option is to: * document that the pointer createHelperPlugin() is only valid in the current call stack * have WebViewImpl::createHelperPlugin() return the WebPlugin (eliminating getPlugin(), which is currently called immediately after it) * clear m_plugin before init(), which is used by createHelperPlugin(), returns. 639518 6 ddorwin 2012-06-01 10:48:51 -0700 Here is some example code that shows how this might be used in Chromium code: WebKit::WebPlugin* plugin = GetClient()->createHelperPlugin("application/x-ppapi-example", frame); webkit::ppapi::WebPluginImpl* ppapi_plugin = static_cast<webkit::ppapi::WebPluginImpl*>(plugin); scoped_refptr<webkit::ppapi::PluginInstance> instance = ppapi_plugin->instance(); instance->DoFoo(); 639759 7 145385 ddorwin 2012-06-01 15:02:47 -0700 Created attachment 145385 Shows possible decorator solution and alternate m_plugin lifetime. Does not compile. 639789 8 145391 ddorwin 2012-06-01 15:34:11 -0700 Created attachment 145391 Shows possible decorator solution and alternate m_plugin lifetime. Would compile with addition of WebFrameClientDecorator. This is a better solution than the first patch. It uses the decorator pattern discussed in Comments #2 and #3 (the decorator is not yet implemented) and somewhat improves the WebPlugin lifetime management as discussed in comment #5 640821 9 145391 abarth 2012-06-04 14:07:04 -0700 Comment on attachment 145391 Shows possible decorator solution and alternate m_plugin lifetime. Would compile with addition of WebFrameClientDecorator. View in context: https://bugs.webkit.org/attachment.cgi?id=145391&action=review > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:105 > + WebPlugin* plugin = > + WebFrameClientDecorator::createPlugin(frame, params); There's no 80 col limit in WebKit, so feel free to use more horizontal space. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:142 > + delete webFrameClient; We generally frown upon calling delete manually. Is there really no object that's a good owner for this object? 640825 10 145391 abarth 2012-06-04 14:16:06 -0700 Comment on attachment 145391 Shows possible decorator solution and alternate m_plugin lifetime. Would compile with addition of WebFrameClientDecorator. View in context: https://bugs.webkit.org/attachment.cgi?id=145391&action=review > Source/WebKit/chromium/ChangeLog:9 > + A WebPlugin is created when the document created by createHelperPlugin() is layed out. > + Return it to the caller so that it can interact with the plugin instance. It's unfortunate that we don't create the plugin until we do layout. That's not really a problem with this patch. It's an architectural problem with WebKit that we've been slowly chipping away at fixing for a while. > Source/WebKit/chromium/public/WebMediaPlayerClient.h:81 > + // The returned pointer is only guaranteed to be valid in this call stack. > + virtual WebPlugin* createHelperPlugin(const WebString& pluginType, WebFrame*) = 0; That's sort of an odd thing to say. There's some weird ownership stuff going on in this patch. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:106 > + m_helperPlugin->setPlugin(plugin); So, we stash off a pointer to the plugin, but according to the comment in createPlugin, plugin will self-destruct as soon as this call stack unwinds. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:118 > + WebHelperPluginImpl* m_helperPlugin; From my previous read though this patch, this is going to end up being a backpointer. I guess that means that WebHelperPluginImpl owns this object. >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:142 >> + delete webFrameClient; > > We generally frown upon calling delete manually. Is there really no object that's a good owner for this object? Why don't we just hold an OwnPtr to the HelperPluginWebFrameClient ? They we don't need any of this fancy business in the destructor. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:160 > + WebPlugin* plugin = m_plugin; > + m_plugin = 0; // Clear the pointer since it is not guaranteed to be valid. So, this was all a hack to return this pointer to this program point (bypassing some intermediate stack frames) ? Oh, because there's a big call stack related to layout before createPlugin actually gets call. I'm starting to understand what's going on here. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:181 > + WebFrameClient* decoratedClient = new HelperPluginWebFrameClient(client, this); Again, WebKit frowns on "naked new". You should call adoptPtr immediately after calling new. That will result in you having an OwnPtr member variable in this class which will handle all the memory management for you. 640827 11 abarth 2012-06-04 14:18:20 -0700 Ok. I understand what this patch is trying to do now. I'd like to recommend a different approach. Rather than trying to hook createPlugin to find the plugin in the helper frame, we should just look for the plugin in the DOM after it gets created. Can't we just initialize everything, and then after things are initialized use getElementsByTagName("object") or something similar to go find the plugin? That's way more direct than what's in the current patch. 640850 12 145391 ddorwin 2012-06-04 14:40:26 -0700 Comment on attachment 145391 Shows possible decorator solution and alternate m_plugin lifetime. Would compile with addition of WebFrameClientDecorator. View in context: https://bugs.webkit.org/attachment.cgi?id=145391&action=review >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:106 >> + m_helperPlugin->setPlugin(plugin); > > So, we stash off a pointer to the plugin, but according to the comment in createPlugin, plugin will self-destruct as soon as this call stack unwinds. This is called within that stack, and it gets used before the stack unwinds (line 159). The plugin doesn't self-destruct, it's just not guaranteed to be valid. The reason for the comment in WebMediaPlayerClient.h is that I don't want the embedder holding the pointer for an extended period. (In reality, there shouldn't be any problems as long as it's not used after closeHelperPlugin() is called.) This could be solved by making WebPlugin RefCounted - any idea what the impact would be? >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:118 >> + WebHelperPluginImpl* m_helperPlugin; > > From my previous read though this patch, this is going to end up being a backpointer. I guess that means that WebHelperPluginImpl owns this object. Yes, is there something to do here? >>> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:142 >>> + delete webFrameClient; >> >> We generally frown upon calling delete manually. Is there really no object that's a good owner for this object? > > Why don't we just hold an OwnPtr to the HelperPluginWebFrameClient ? They we don't need any of this fancy business in the destructor. Yes, I think I can handle all this in the declaration. >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:160 >> + m_plugin = 0; // Clear the pointer since it is not guaranteed to be valid. > > So, this was all a hack to return this pointer to this program point (bypassing some intermediate stack frames) ? > > Oh, because there's a big call stack related to layout before createPlugin actually gets call. I'm starting to understand what's going on here. Yes. WebPlugin is converted to a PluginContainer, which is returned as a Widget. All information about the plugin is lost in the call stack from this function to createPlugin(). >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:181 >> + WebFrameClient* decoratedClient = new HelperPluginWebFrameClient(client, this); > > Again, WebKit frowns on "naked new". You should call adoptPtr immediately after calling new. That will result in you having an OwnPtr member variable in this class which will handle all the memory management for you. Will fix. 640863 13 abarth 2012-06-04 14:56:21 -0700 > This could be solved by making WebPlugin RefCounted - any idea what the impact would be? That doesn't seem to be necessary. > >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:118 > >> + WebHelperPluginImpl* m_helperPlugin; > > > > From my previous read though this patch, this is going to end up being a backpointer. I guess that means that WebHelperPluginImpl owns this object. > > Yes, is there something to do here? Nope. I'm just talking through the patch out loud so you can tell me if I'm off my rocker. > > Oh, because there's a big call stack related to layout before createPlugin actually gets call. I'm starting to understand what's going on here. > > Yes. WebPlugin is converted to a PluginContainer, which is returned as a Widget. All information about the plugin is lost in the call stack from this function to createPlugin(). What do you think about the approach of retrieving the WebPlugin from the DOM rather than hooking createPlugin ? 640893 14 ddorwin 2012-06-04 15:22:07 -0700 (In reply to comment #11) > Ok. I understand what this patch is trying to do now. I'd like to recommend a different approach. > > Rather than trying to hook createPlugin to find the plugin in the helper frame, we should just look for the plugin in the DOM after it gets created. Can't we just initialize everything, and then after things are initialized use getElementsByTagName("object") or something similar to go find the plugin? That's way more direct than what's in the current patch. Do you mean to do this in WebHelperPluginImpl or from outside it? How do you suggest we get the WebPlugin from a Node*? I think it might look something like this, which is maybe not as horrible as I thought it would be. Node* node = NodeList[0]; Widget* widget = static_cast<HTMLPlugInElement*>(node)->pluginWidget(); WebPlugin* plugin = <WebPluginContainerImpl*>(widget)->plugin(); I think we still have the lifetime issue to address. FWIW, ~WebPluginContainerImpl() calls m_webPlugin->destroy(), which results in a deferred deletion. Thus, the WebPlugin is valid until the <object> element is destroyed, which should only happen after closeHelperPlugin() is called to destroy the offscreen page. If we wanted to, we could define the lifetime as it was in the first patch: // The returned pointer is valid until closeHelperPlugin() is called. 640931 15 abarth 2012-06-04 15:57:27 -0700 > Do you mean to do this in WebHelperPluginImpl or from outside it? How do you suggest we get the WebPlugin from a Node*? > > I think it might look something like this, which is maybe not as horrible as I thought it would be. > Node* node = NodeList[0]; > Widget* widget = static_cast<HTMLPlugInElement*>(node)->pluginWidget(); > WebPlugin* plugin = <WebPluginContainerImpl*>(widget)->plugin(); That looks reasonable. We can add some ASSERTs regarding the tagName of the node. > I think we still have the lifetime issue to address. > > FWIW, ~WebPluginContainerImpl() calls m_webPlugin->destroy(), which results in a deferred deletion. Thus, the WebPlugin is valid until the <object> element is destroyed, which should only happen after closeHelperPlugin() is called to destroy the offscreen page. If we wanted to, we could define the lifetime as it was in the first patch: > > // The returned pointer is valid until closeHelperPlugin() is called. That seems like a reasonable statement about the lifetime. 642077 16 ddorwin 2012-06-05 18:30:30 -0700 Quick update: I have the getElementsByTagName() solution working in general, but I need to sort out some corner cases before uploading. 643065 17 146173 ddorwin 2012-06-06 18:38:11 -0700 Created attachment 146173 Use getElementsByTagName() to get the WebPlugin Implemented using the getElementsByTagName() per the suggestion in comment #11 643066 18 ddorwin 2012-06-06 18:40:02 -0700 I tested the following scenarios (using Chromium changes that exercise this code): * Plugin present and enabled * Plugin not present (file not found) * Plugin present and not enabled * Enabling plugin between attempts to create helper plugin - This one is interesting because the disabled plugin is a placeholder, and enabling the plugin would destroy the placeholder WebPlugin. Thus, we do not return placeholders. * Disabling plugin after creating helper plugin I also found and fixed a bug where Chromium's ExtensionHelper would hang on to the WebFrame even after it was destroyed by calling frameDetached() in ~WebFrameImpl(). 643069 19 webkit.review.bot 2012-06-06 18:41:13 -0700 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 643991 20 146173 abarth 2012-06-07 15:31:14 -0700 Comment on attachment 146173 Use getElementsByTagName() to get the WebPlugin View in context: https://bugs.webkit.org/attachment.cgi?id=146173&action=review > Source/WebKit/chromium/public/WebHelperPlugin.h:48 > + // The returned pointer may be 0 even if initialization was successful. We should have a blank line above this line. > Source/WebKit/chromium/public/WebPlugin.h:143 > + virtual bool isPpapi() { return false; } I'm not 100% sure if this function is correct. My understand was that WebKit should be ignorant of PPAPI. > Source/WebKit/chromium/src/WebFrameImpl.cpp:2062 > + // Tell the client that this object is no longer valid. > + if (client()) > + client()->frameDetached(this); I'm not sure I understand this part of your patch. Is there a general bug in the WebFrame lifecycle that we haven't noticed until now? Is there something strange about the helper plugin that's triggering the need for this extra lifecycle call? > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:155 > + RefPtr<NodeList> objectElements = m_page->mainFrame()->document()->getElementsByTagName("object"); Rather than the string literal "object", you can use objectTag from HTMLNames.h Do we want to return 0 if this returns an empty list? That could happen, for example, if the embedder calls this function too early. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:158 > + WebCore::Widget* widget = reinterpret_cast<HTMLPlugInElement*>(node)->pluginWidget(); reinterpret_cast -> static_cast Do you want to add an ASSERT(node->hasTagName(objectTag)) ? I guess that's pretty redundant with getElementsByTagName. > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:161 > + WebPlugin* plugin = reinterpret_cast<WebPluginContainerImpl*>(widget)->plugin(); reinterpret_cast -> static_cast 643995 21 146173 jamesr 2012-06-07 15:33:10 -0700 Comment on attachment 146173 Use getElementsByTagName() to get the WebPlugin View in context: https://bugs.webkit.org/attachment.cgi?id=146173&action=review >> Source/WebKit/chromium/public/WebPlugin.h:143 >> + virtual bool isPpapi() { return false; } > > I'm not 100% sure if this function is correct. My understand was that WebKit should be ignorant of PPAPI. This is definitely wrong. I see no callers of this function, why are you adding it? 644060 22 146173 ddorwin 2012-06-07 16:43:55 -0700 Comment on attachment 146173 Use getElementsByTagName() to get the WebPlugin I made all the requested changes as noted below. The remaining issues are: * Alternatives, if any, to isPpapi(). * WebFrame lifetime issue. View in context: https://bugs.webkit.org/attachment.cgi?id=146173&action=review >> Source/WebKit/chromium/public/WebHelperPlugin.h:48 >> + // The returned pointer may be 0 even if initialization was successful. > > We should have a blank line above this line. Done. >>> Source/WebKit/chromium/public/WebPlugin.h:143 >>> + virtual bool isPpapi() { return false; } >> >> I'm not 100% sure if this function is correct. My understand was that WebKit should be ignorant of PPAPI. > > This is definitely wrong. I see no callers of this function, why are you adding it? Okay. (FWIW, this is the Chromium-specific part of WebKit.) This function would be used by Chromium code to verify the plugin type before casting a WebKit::WebPlugin* to a webkit::ppapi::WebPluginImpl*. See the example code in comment #6. Since the Chromium code knows what plugin it asked for, this is really just an additional safety measure. If plugins are either placeholders, NPAPI, or PPAPI, then the WebPlugin should always be a ppapi::WebPluginImpl because it's not NPAPI and placeholders are not returned. I was following the isMediaControlElement() pattern, though media controls are obviously common to all WebKit ports. Any other suggestions options for verifying the type? >> Source/WebKit/chromium/src/WebFrameImpl.cpp:2062 >> + client()->frameDetached(this); > > I'm not sure I understand this part of your patch. Is there a general bug in the WebFrame lifecycle that we haven't noticed until now? Is there something strange about the helper plugin that's triggering the need for this extra lifecycle call? This was briefly mentioned in comment #18, but I'll provide more details here. I believe this code exposes a scenario where the lifetime isn't properly managed. I'm open to other suggestions on how to resolve this. The initialization of the new WebFrame causes clients to be informed via DidCreateDataSource(). One of those is ExtensionHelper, which creates a UserScriptScheduler that holds a raw pointer to the WebFrame. (This is the only code I could find where such a pointer was _stored_.) Ideally, this would be some type of refptr, but we don't use RefPtrs in the chromium/public APIs. While holding the raw pointer seems like a bad idea, at least the object holding the pointer is deleted if frameDetached() is called. When the plugin cannot be instantiated (i.e. it is disabled), getPlugin() returns 0 and WebMediaPlayerClientImpl::createHelperPlugin() destroys the WebHelperPlugin in the same call stack (after DidCreateDataSource() is called). This causes the WebFrame to be destroyed. Since we don't inform the clients, the extensions code is still holding a raw pointer to the deleted WebFrame. The extensions code also apparently schedules a task to run on the main thread and inject extension scripts. This task gets executed after the current task, which called createHelperPlugin(), completes. It tries to use the stored pointer and crashes. There are two possibly unique things about this code: 1) A WebFrame is created and destroyed in the same call stack. In all other cases, script-injecting task would probably run between creation and destruction. 2) The WebFrame is destroyed without ever being detached. If it was detached, frameDetached() would be called before the frame is deleted. I don't know under what conditions a frame is detached before being destroyed. Maybe the problem above could be resolved by posting the WebHelperPlugin destruction. However, it's not clear to me that the script-injecting task is the only one that will run and nothing guarantees that other clients won't hold such pointers in the future. A workaround would be to disable extensions for this frame (something that might be useful anyway), but I didn't find a way to do that. >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:155 >> + RefPtr<NodeList> objectElements = m_page->mainFrame()->document()->getElementsByTagName("object"); > > Rather than the string literal "object", you can use objectTag from HTMLNames.h > > Do we want to return 0 if this returns an empty list? That could happen, for example, if the embedder calls this function too early. Done. Done. I left an assert since this is a programming error but will remove it if preferred. >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:158 >> + WebCore::Widget* widget = reinterpret_cast<HTMLPlugInElement*>(node)->pluginWidget(); > > reinterpret_cast -> static_cast > > Do you want to add an ASSERT(node->hasTagName(objectTag)) ? I guess that's pretty redundant with getElementsByTagName. cast changed. Yes, it's pretty redundant, but I added it anyway. isPluginElement() would be more helpful, but it didn't seem worth adding to Node. >> Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:161 >> + WebPlugin* plugin = reinterpret_cast<WebPluginContainerImpl*>(widget)->plugin(); > > reinterpret_cast -> static_cast Done. 644070 23 jamesr 2012-06-07 16:50:22 -0700 (In reply to comment #22) > >>> Source/WebKit/chromium/public/WebPlugin.h:143 > >>> + virtual bool isPpapi() { return false; } > >> > >> I'm not 100% sure if this function is correct. My understand was that WebKit should be ignorant of PPAPI. > > > > This is definitely wrong. I see no callers of this function, why are you adding it? > > Okay. (FWIW, this is the Chromium-specific part of WebKit.) > > This function would be used by Chromium code to verify the plugin type before casting a WebKit::WebPlugin* to a webkit::ppapi::WebPluginImpl*. See the example code in comment #6. > Since the Chromium code knows what plugin it asked for, this is really just an additional safety measure. If plugins are either placeholders, NPAPI, or PPAPI, then the WebPlugin should always be a ppapi::WebPluginImpl because it's not NPAPI and placeholders are not returned. > This is a embedder-specific concern, it shouldn't infect the API. 644073 24 146417 ddorwin 2012-06-07 16:51:19 -0700 Created attachment 146417 Review feedback 644109 25 abarth 2012-06-07 17:27:06 -0700 > which creates a UserScriptScheduler that holds a raw pointer to the WebFrame I suspect that this is the bug. We shouldn't be holding raw pointers to WebFrame. There's nothing keeping them alive. I suspect that this code can crash in other situations when things get scheduled on the event loop in a slightly different order. 644119 26 abarth 2012-06-07 17:31:26 -0700 Are you calling webView->close() ? It looks like that should call start the teardown process. 644124 27 abarth 2012-06-07 17:34:59 -0700 (If you are calling close(), we might want to try to understand why the signal isn't getting routed all the way back out to the client.) 644135 28 ddorwin 2012-06-07 17:44:06 -0700 (In reply to comment #23) > (In reply to comment #22) > > >>> Source/WebKit/chromium/public/WebPlugin.h:143 > > >>> + virtual bool isPpapi() { return false; } > > >> > > >> I'm not 100% sure if this function is correct. My understand was that WebKit should be ignorant of PPAPI. > > > > > > This is definitely wrong. I see no callers of this function, why are you adding it? > > > > Okay. (FWIW, this is the Chromium-specific part of WebKit.) > > > > This function would be used by Chromium code to verify the plugin type before casting a WebKit::WebPlugin* to a webkit::ppapi::WebPluginImpl*. See the example code in comment #6. > > Since the Chromium code knows what plugin it asked for, this is really just an additional safety measure. If plugins are either placeholders, NPAPI, or PPAPI, then the WebPlugin should always be a ppapi::WebPluginImpl because it's not NPAPI and placeholders are not returned. > > > > This is a embedder-specific concern, it shouldn't infect the API. Makes sense. The correct way to solve this would probably be to have a common WebPluginImpl base in Chromium that has such a function and have NPAPI, PPAPI, etc. inherit from it. Today, they all inherit directly from WebPlugin. In any case, It has been removed from WebPlugin 644157 29 ddorwin 2012-06-07 18:05:28 -0700 (In reply to comment #25) > > which creates a UserScriptScheduler that holds a raw pointer to the WebFrame > > I suspect that this is the bug. We shouldn't be holding raw pointers to WebFrame. There's nothing keeping them alive. I suspect that this code can crash in other situations when things get scheduled on the event loop in a slightly different order. Is this a bug regardless of the discussion below? If so, I'll file a Chromium bug. (In reply to comment #26) > Are you calling webView->close() ? It looks like that should call start the teardown process. No. WebHelperPluginImpl, like WebPagePopupImpl, uses the hosting page's WebView, so we can't close it. They could perform the important step(s) from close() in their own teardown code. Specifically, calling m_page->mainFrame()->loader()->frameDetached() from their close() functions. That seems like the right fix. Should a frame always be detached before ~WebFrameImpl() runs? If so, is there any thing we can assert on to prevent such mistakes in the future? 644172 30 146173 ddorwin 2012-06-07 18:26:40 -0700 Comment on attachment 146173 Use getElementsByTagName() to get the WebPlugin View in context: https://bugs.webkit.org/attachment.cgi?id=146173&action=review >>> Source/WebKit/chromium/src/WebFrameImpl.cpp:2062 >>> + client()->frameDetached(this); >> >> I'm not sure I understand this part of your patch. Is there a general bug in the WebFrame lifecycle that we haven't noticed until now? Is there something strange about the helper plugin that's triggering the need for this extra lifecycle call? > > This was briefly mentioned in comment #18, but I'll provide more details here. I believe this code exposes a scenario where the lifetime isn't properly managed. I'm open to other suggestions on how to resolve this. > > The initialization of the new WebFrame causes clients to be informed via DidCreateDataSource(). One of those is ExtensionHelper, which creates a UserScriptScheduler that holds a raw pointer to the WebFrame. (This is the only code I could find where such a pointer was _stored_.) Ideally, this would be some type of refptr, but we don't use RefPtrs in the chromium/public APIs. While holding the raw pointer seems like a bad idea, at least the object holding the pointer is deleted if frameDetached() is called. > > When the plugin cannot be instantiated (i.e. it is disabled), getPlugin() returns 0 and WebMediaPlayerClientImpl::createHelperPlugin() destroys the WebHelperPlugin in the same call stack (after DidCreateDataSource() is called). This causes the WebFrame to be destroyed. Since we don't inform the clients, the extensions code is still holding a raw pointer to the deleted WebFrame. > > The extensions code also apparently schedules a task to run on the main thread and inject extension scripts. This task gets executed after the current task, which called createHelperPlugin(), completes. It tries to use the stored pointer and crashes. > > There are two possibly unique things about this code: > 1) A WebFrame is created and destroyed in the same call stack. In all other cases, script-injecting task would probably run between creation and destruction. > 2) The WebFrame is destroyed without ever being detached. If it was detached, frameDetached() would be called before the frame is deleted. I don't know under what conditions a frame is detached before being destroyed. > > Maybe the problem above could be resolved by posting the WebHelperPlugin destruction. However, it's not clear to me that the script-injecting task is the only one that will run and nothing guarantees that other clients won't hold such pointers in the future. > > A workaround would be to disable extensions for this frame (something that might be useful anyway), but I didn't find a way to do that. Slight correction: The WebFrame is NOT created and destroyed in the same call stack because closeWidgetSoon() causes close() to be called asynchronously. It looks like the extension task runs as the result of an idle timeout, so it may just be a timing issue as to whether that specific task runs between creation of the HelperPlugin's frame and and close(). Nevertheless, we have a better solution as discussed in the comments. 644176 31 146442 ddorwin 2012-06-07 18:32:01 -0700 Created attachment 146442 Call frameDetached() from WebHelperPluginImpl::close() 644180 32 146442 abarth 2012-06-07 18:35:12 -0700 Comment on attachment 146442 Call frameDetached() from WebHelperPluginImpl::close() View in context: https://bugs.webkit.org/attachment.cgi?id=146442&action=review > Source/WebKit/chromium/src/WebHelperPluginImpl.cpp:231 > + m_page->mainFrame()->loader()->frameDetached(); Ah, if this works, this is much better. This will trigger all the WebCore internal state to be cleaned up as well. 644830 33 abarth 2012-06-08 10:59:55 -0700 @ddorwin: If you'd like this landed via the commit-queue, you can set the commit-queue? flag and any committer can set commit-queue+. 646114 34 146442 webkit.review.bot 2012-06-11 11:14:32 -0700 Comment on attachment 146442 Call frameDetached() from WebHelperPluginImpl::close() Clearing flags on attachment: 146442 Committed r119988: <http://trac.webkit.org/changeset/119988> 646115 35 webkit.review.bot 2012-06-11 11:14:40 -0700 All reviewed patches have been landed. Closing bug. 145180 2012-05-31 17:41:14 -0700 2012-06-06 18:38:00 -0700 Patch for initial feedback bug-88028-20120531174113.patch text/plain 11908 ddorwin ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMTViMDRlNWE3MzlhMjJmNTEwZWQ4ZDBkODFl ZGNlOWMwOTJhZTE3OS4uMzY0YTU3ODAyZWUxN2IzNThjZGY5YTM5YzNiMzFiZWQ0YTk4NzhjYSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0MiBAQAorMjAxMi0wNS0zMSAg RGF2aWQgRG9yd2luICA8ZGRvcndpbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV0dXJuIGEg cG9pbnRlciB0byB0aGUgV2ViUGx1Z2luIGNyZWF0ZWQgYnkgY3JlYXRlSGVscGVyUGx1Z2luKCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4MDI4CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQSBXZWJQbHVn aW4gaXMgY3JlYXRlZCB3aGVuIHRoZSBkb2N1bWVudCBjcmVhdGVkIGJ5IGNyZWF0ZUhlbHBlclBs dWdpbigpIGlzIGxheWVkIG91dC4KKyAgICAgICAgUmV0dXJuIGl0IHRvIHRoZSBjYWxsZXIgc28g dGhhdCBpdCBjYW4gaW50ZXJhY3Qgd2l0aCB0aGUgcGx1Z2luIGluc3RhbmNlLgorCisgICAgICAg ICogcHVibGljL1dlYkhlbHBlclBsdWdpbi5oOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAg KFdlYkhlbHBlclBsdWdpbik6CisgICAgICAgICogcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50 Lmg6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAqIHNyYy9GcmFtZUxvYWRlckNsaWVudElt cGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudEltcGw6OmNyZWF0ZVBs dWdpbik6CisgICAgICAgICogc3JjL1dlYkZyYW1lSW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6 OldlYkZyYW1lSW1wbDo6Y3JlYXRlUGx1Z2luKToKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAg ICogc3JjL1dlYkZyYW1lSW1wbC5oOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYkZy YW1lSW1wbCk6CisgICAgICAgICogc3JjL1dlYkhlbHBlclBsdWdpbkltcGwuY3BwOgorICAgICAg ICAoSGVscGVyUGx1Z2luV2ViRnJhbWUpOgorICAgICAgICAoV2ViS2l0OjpIZWxwZXJQbHVnaW5X ZWJGcmFtZTo6fkhlbHBlclBsdWdpbldlYkZyYW1lKToKKyAgICAgICAgKFdlYktpdDo6SGVscGVy UGx1Z2luV2ViRnJhbWU6OmdldFBsdWdpbik6CisgICAgICAgIChXZWJLaXQ6OkhlbHBlclBsdWdp bldlYkZyYW1lOjpjcmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpIZWxwZXJQbHVnaW5XZWJGcmFt ZTo6SGVscGVyUGx1Z2luV2ViRnJhbWUpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdl YktpdDo6V2ViSGVscGVyUGx1Z2luSW1wbDo6aW5pdGlhbGl6ZUZyYW1lKToKKyAgICAgICAgKFdl YktpdDo6V2ViSGVscGVyUGx1Z2luSW1wbDo6Z2V0UGx1Z2luKToKKyAgICAgICAgKiBzcmMvV2Vi SGVscGVyUGx1Z2luSW1wbC5oOgorICAgICAgICAoV2ViSGVscGVyUGx1Z2luSW1wbCk6CisgICAg ICAgICogc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6 OldlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKToKKyAgICAgICAg KiBzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmg6CisgICAgICAgIChXZWJNZWRpYVBsYXll ckNsaWVudEltcGwpOgorCiAyMDEyLTA1LTMwICBEYXZpZCBEb3J3aW4gIDxkZG9yd2luQGNocm9t aXVtLm9yZz4KIAogICAgICAgICBFbmFibGUgQ2hyb21pdW0gbWVkaWEgcGxheWVyIHRvIGluc3Rh bnRpYXRlIGEgcGx1Z2luCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1Ymxp Yy9XZWJIZWxwZXJQbHVnaW4uaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkhl bHBlclBsdWdpbi5oCmluZGV4IGI2Y2MxN2QyNjhhMTllOWUxNzk0ZDQzNmZiMDcyNTc2Yjk4NjNm MDUuLjBiMjU1MmFiYWNiYzM0MjJiYzY1NDI4NmZkZmIwMzBhYzU1NjUzOGQgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkhlbHBlclBsdWdpbi5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkhlbHBlclBsdWdpbi5oCkBAIC0zNyw2ICsz Nyw3IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViRnJhbWVDbGllbnQ7CitjbGFz cyBXZWJQbHVnaW47CiBjbGFzcyBXZWJXaWRnZXRDbGllbnQ7CiAKIGNsYXNzIFdlYkhlbHBlclBs dWdpbiA6IHB1YmxpYyBXZWJXaWRnZXQgewpAQCAtNDUsNiArNDYsOCBAQCBwdWJsaWM6CiAKICAg ICB2aXJ0dWFsIHZvaWQgaW5pdGlhbGl6ZUZyYW1lKFdlYkZyYW1lQ2xpZW50KikgPSAwOwogCisg ICAgdmlydHVhbCBXZWJQbHVnaW4qIGdldFBsdWdpbigpID0gMDsKKwogcHJvdGVjdGVkOgogICAg IH5XZWJIZWxwZXJQbHVnaW4oKSB7IH0KIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXJDbGllbnQuaAppbmRleCBhNDZlZTVjZWQ0OGFjOWY1 ODVmYzFkZGQyNGZhMDIyMTgyYjRlMTk4Li4xZWMyNTYzZjdiM2RiYzFkZDMyNWM4YmY0MzYwN2M4 YjQ2MGU2NWQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJN ZWRpYVBsYXllckNsaWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl Yk1lZGlhUGxheWVyQ2xpZW50LmgKQEAgLTM2LDYgKzM2LDcgQEAKIG5hbWVzcGFjZSBXZWJLaXQg ewogCiBjbGFzcyBXZWJGcmFtZTsKK2NsYXNzIFdlYlBsdWdpbjsKIGNsYXNzIFdlYlJlcXVlc3Q7 CiBjbGFzcyBXZWJVUkw7CiAKQEAgLTc2LDcgKzc3LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwg dm9pZCBrZXlFcnJvcihjb25zdCBXZWJTdHJpbmcmLCBjb25zdCBXZWJTdHJpbmcmLCBNZWRpYUtl eUVycm9yQ29kZSwgdW5zaWduZWQgc2hvcnQgc3lzdGVtQ29kZSkgPSAwOwogICAgIHZpcnR1YWwg dm9pZCBrZXlNZXNzYWdlKGNvbnN0IFdlYlN0cmluZyYsIGNvbnN0IFdlYlN0cmluZyYsIGNvbnN0 IHVuc2lnbmVkIGNoYXIqLCB1bnNpZ25lZCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBrZXlOZWVk ZWQoY29uc3QgV2ViU3RyaW5nJiwgY29uc3QgV2ViU3RyaW5nJiwgY29uc3QgdW5zaWduZWQgY2hh ciogaW5pdERhdGEsIHVuc2lnbmVkIGluaXREYXRhTGVuZ3RoKSA9IDA7Ci0gICAgdmlydHVhbCB2 b2lkIGNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZy YW1lKikgPSAwOworICAgIC8vIFRoZSByZXR1cm5lZCBwb2ludGVyIGlzIHZhbGlkIHVudGlsIGNs b3NlSGVscGVyUGx1Z2luKCkgaXMgY2FsbGVkLgorICAgIHZpcnR1YWwgV2ViUGx1Z2luKiBjcmVh dGVIZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSopID0g MDsKKyAgICAvLyBUaGUgV2ViUGx1Z2luIHJldHVybmVkIGNyZWF0ZUhlbHBlclBsdWdpbiBpcyBu byBsb25nZXIgdmFsaWQgYWZ0ZXIgY2FsbGluZyB0aGlzIG1ldGhvZC4KICAgICB2aXJ0dWFsIHZv aWQgY2xvc2VIZWxwZXJQbHVnaW4oKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGRpc2FibGVBY2Nl bGVyYXRlZENvbXBvc2l0aW5nKCkgPSAwOwogcHJvdGVjdGVkOgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcCBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5jcHAKaW5kZXggYzQyOTc5 Y2EzN2I3NGFhZDg5YzdlYTJiMjM0ODcyMTk2OTIyMGZiMi4uYThjMjRhZjcwYjRiMDcyNDU3Njhh M2M2MzI2OGVlNzMyNjJjYWI0ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9GcmFtZUxvYWRlckNsaWVudEltcGwuY3BwCkBAIC0xNDc4LDcgKzE0NzgsNyBAQCBQYXNz UmVmUHRyPFdpZGdldD4gRnJhbWVMb2FkZXJDbGllbnRJbXBsOjpjcmVhdGVQbHVnaW4oCiAgICAg cGFyYW1zLmF0dHJpYnV0ZVZhbHVlcyA9IHBhcmFtVmFsdWVzOwogICAgIHBhcmFtcy5sb2FkTWFu dWFsbHkgPSBsb2FkTWFudWFsbHk7CiAKLSAgICBXZWJQbHVnaW4qIHdlYlBsdWdpbiA9IG1fd2Vi RnJhbWUtPmNsaWVudCgpLT5jcmVhdGVQbHVnaW4obV93ZWJGcmFtZSwgcGFyYW1zKTsKKyAgICBX ZWJQbHVnaW4qIHdlYlBsdWdpbiA9IG1fd2ViRnJhbWUtPmNyZWF0ZVBsdWdpbihwYXJhbXMpOwog ICAgIGlmICghd2ViUGx1Z2luKQogICAgICAgICByZXR1cm4gMDsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViRnJhbWVJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkZyYW1lSW1wbC5jcHAKaW5kZXggNzNiZjNmYWE1Yzg3MTNiODUyMTBh MDQ0NjM4MDMyZjE0YzExNWEyNi4uZDk4MzdlY2M4MDU2Y2IxZWI3ZWYxYzJmY2Y0ZDQ2OWY4NTI4 ZmIxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViRnJhbWVJbXBs LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJGcmFtZUltcGwuY3BwCkBA IC0yMDE1LDYgKzIwMTUsMTEgQEAgV2ViU3RyaW5nIFdlYkZyYW1lSW1wbDo6bGF5ZXJUcmVlQXNU ZXh0KGJvb2wgc2hvd0RlYnVnSW5mbykgY29uc3QKIAogLy8gV2ViRnJhbWVJbXBsIHB1YmxpYyAt LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K IAorV2ViUGx1Z2luKiBXZWJGcmFtZUltcGw6OmNyZWF0ZVBsdWdpbihjb25zdCBXZWJQbHVnaW5Q YXJhbXMmIHBhcmFtcykKK3sKKyAgICByZXR1cm4gY2xpZW50KCktPmNyZWF0ZVBsdWdpbih0aGlz LCBwYXJhbXMpOworfQorCiBQYXNzUmVmUHRyPFdlYkZyYW1lSW1wbD4gV2ViRnJhbWVJbXBsOjpj cmVhdGUoV2ViRnJhbWVDbGllbnQqIGNsaWVudCkKIHsKICAgICByZXR1cm4gYWRvcHRSZWYobmV3 IFdlYkZyYW1lSW1wbChjbGllbnQpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYkZyYW1lSW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViRnJh bWVJbXBsLmgKaW5kZXggMDE0NmJkNWJkN2U5MGViYTY5MWFlYzAzNzQ1ZGExYjJmMzhiNmNiMi4u ZjczYWFhN2JiZjY1N2QxOWQ5NjQ4YmQwN2QzZDNjYWYwNTdkM2U3ZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViRnJhbWVJbXBsLmgKKysrIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViRnJhbWVJbXBsLmgKQEAgLTYwLDkgKzYwLDExIEBAIGNsYXNzIFdl YklucHV0RWxlbWVudDsKIGNsYXNzIFdlYkludGVudDsKIGNsYXNzIFdlYkZyYW1lQ2xpZW50Owog Y2xhc3MgV2ViUGVyZm9ybWFuY2U7CitjbGFzcyBXZWJQbHVnaW47CiBjbGFzcyBXZWJQbHVnaW5D b250YWluZXJJbXBsOwogY2xhc3MgV2ViVmlldzsKIGNsYXNzIFdlYlZpZXdJbXBsOworc3RydWN0 IFdlYlBsdWdpblBhcmFtczsKIHN0cnVjdCBXZWJQcmludFBhcmFtczsKIAogdGVtcGxhdGUgPHR5 cGVuYW1lIFQ+IGNsYXNzIFdlYlZlY3RvcjsKQEAgLTIzMiw2ICsyMzQsOSBAQCBwdWJsaWM6CiAg ICAgdmlydHVhbCBib29sIHNlbGVjdGlvblN0YXJ0SGFzU3BlbGxpbmdNYXJrZXJGb3IoaW50IGZy b20sIGludCBsZW5ndGgpIGNvbnN0OwogICAgIHZpcnR1YWwgV2ViU3RyaW5nIGxheWVyVHJlZUFz VGV4dChib29sIHNob3dEZWJ1Z0luZm8gPSBmYWxzZSkgY29uc3Q7CiAKKyAgICAvLyBXZWJGcmFt ZUltcGwgcHVibGljIG1ldGhvZHM6CisgICAgdmlydHVhbCBXZWJQbHVnaW4qIGNyZWF0ZVBsdWdp bihjb25zdCBXZWJQbHVnaW5QYXJhbXMmKTsKKwogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFdlYkZy YW1lSW1wbD4gY3JlYXRlKFdlYkZyYW1lQ2xpZW50KiBjbGllbnQpOwogICAgIHZpcnR1YWwgfldl YkZyYW1lSW1wbCgpOwogCkBAIC0yODUsNiArMjkwLDkgQEAgcHVibGljOgogCiAgICAgc3RhdGlj IHZvaWQgc2VsZWN0V29yZEFyb3VuZFBvc2l0aW9uKFdlYkNvcmU6OkZyYW1lKiwgV2ViQ29yZTo6 VmlzaWJsZVBvc2l0aW9uKTsKIAorcHJvdGVjdGVkOgorICAgIGV4cGxpY2l0IFdlYkZyYW1lSW1w bChXZWJGcmFtZUNsaWVudCopOworCiBwcml2YXRlOgogICAgIGNsYXNzIERlZmVycmVkU2NvcGVT dHJpbmdNYXRjaGVzOwogICAgIGZyaWVuZCBjbGFzcyBEZWZlcnJlZFNjb3BlU3RyaW5nTWF0Y2hl czsKQEAgLTI5OCw4ICszMDYsNiBAQCBwcml2YXRlOgogICAgICAgSW52YWxpZGF0ZUFsbCAgICAg ICAgICAvLyBCb3RoIGNvbnRlbnQgYXJlYSBhbmQgdGhlIHNjcm9sbGJhci4KICAgICB9OwogCi0g ICAgV2ViRnJhbWVJbXBsKFdlYkZyYW1lQ2xpZW50Kik7Ci0KICAgICAvLyBJbmZvcm1zIHRoZSBX ZWJGcmFtZSB0aGF0IHRoZSBGcmFtZSBpcyBiZWluZyBjbG9zZWQsIGNhbGxlZCBieSB0aGUKICAg ICAvLyBXZWJGcmFtZUxvYWRlckNsaWVudAogICAgIHZvaWQgY2xvc2luZygpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5jcHAgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcAppbmRleCBj ZGY0YTIxNDk2ZmUzNmZlMzAzOTI2ZjQ4YzBlZTBmM2JiMzAwNDcxLi5jMWViMDg4MjJmNmU2ZmU3 N2Q4OWUxMWI4MzNlYmVmNWIyNDVkNzRiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcApAQCAtODcsNiArODcsNDIgQEAgcHJpdmF0 ZToKICAgICBXZWJIZWxwZXJQbHVnaW5JbXBsKiBtX3dpZGdldDsKIH07CiAKK2NsYXNzIEhlbHBl clBsdWdpbldlYkZyYW1lIDogcHVibGljIFdlYkZyYW1lSW1wbCB7CitwdWJsaWM6CisgICAgLy8g Q3JlYXRlcyBhIHBsdWdpbiB1c2luZyB0aGUgcGFyZW50IGNsYXNzIGFuZCBzdG9yZXMgYSBwb2lu dGVyIHRvIGl0LgorICAgIC8vIEFzc3VtZXMgdGhlIFdlYlBsdWdpbiBpcyB2YWxpZCBhcyBsb25n IGFzIHRoaXMgY2xhc3MgZXhpc3RzLgorICAgIHZpcnR1YWwgV2ViUGx1Z2luKiBjcmVhdGVQbHVn aW4oY29uc3QgV2ViUGx1Z2luUGFyYW1zJiBwYXJhbXMpIE9WRVJSSURFCisgICAgeworICAgICAg ICBtX3BsdWdpbiA9IFdlYkZyYW1lSW1wbDo6Y3JlYXRlUGx1Z2luKHBhcmFtcyk7CisgICAgICAg IHJldHVybiBtX3BsdWdpbjsKKyAgICB9CisKKyAgICB2aXJ0dWFsIH5IZWxwZXJQbHVnaW5XZWJG cmFtZSgpCisgICAgeworICAgICAgICAvLyBFbnN1cmUgdGhlIHBsdWdpbiBpcyBub3QgdXNlZCBk dXJpbmcgZGVzdHJ1Y3Rpb24gb2YgdGhlIHBhcmVudCBjbGFzcy4KKyAgICAgICAgbV9wbHVnaW4g PSAwOworICAgIH0KKworICAgIC8vIEZJWE1FOiBQcm92aWRlIHRoaXMgYnkgY2FsbGluZyBhIGNs aWVudCBpZiB3ZSBrZWVwIHRoaXMgZGVzaWduLiBTZWUgRklYTUUgYmVsb3cuCisgICAgV2ViUGx1 Z2luKiBnZXRQbHVnaW4oKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG1fcGx1Z2luOworICAgIH0K KworICAgIHN0YXRpYyBQYXNzUmVmUHRyPFdlYkZyYW1lSW1wbD4gY3JlYXRlKFdlYkZyYW1lQ2xp ZW50KiBjbGllbnQpCisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEhlbHBlclBs dWdpbldlYkZyYW1lKGNsaWVudCkpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBI ZWxwZXJQbHVnaW5XZWJGcmFtZShXZWJGcmFtZUNsaWVudCogY2xpZW50KQorICAgICAgICA6IFdl YkZyYW1lSW1wbChjbGllbnQpCisgICAgICAgICwgbV9wbHVnaW4oMCkgeyB9CisKKyAgICBXZWJQ bHVnaW4qIG1fcGx1Z2luOworfTsKKworCiAvLyBXZWJIZWxwZXJQbHVnaW5JbXBsIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K IAogV2ViSGVscGVyUGx1Z2luSW1wbDo6V2ViSGVscGVyUGx1Z2luSW1wbChXZWJXaWRnZXRDbGll bnQqIGNsaWVudCkKQEAgLTEzMSw4ICsxNjcsMTcgQEAgdm9pZCBXZWJIZWxwZXJQbHVnaW5JbXBs OjpjbG9zZUhlbHBlclBsdWdpbigpCiB2b2lkIFdlYkhlbHBlclBsdWdpbkltcGw6OmluaXRpYWxp emVGcmFtZShXZWJGcmFtZUNsaWVudCogY2xpZW50KQogewogICAgIEFTU0VSVChtX3BhZ2UpOwot ICAgIFJlZlB0cjxXZWJGcmFtZUltcGw+IGZyYW1lID0gV2ViRnJhbWVJbXBsOjpjcmVhdGUoY2xp ZW50KTsKLSAgICBmcmFtZS0+aW5pdGlhbGl6ZUFzTWFpbkZyYW1lKG1fcGFnZS5nZXQoKSk7Cisg ICAgLy8gRklYTUU6IFJhdGhlciB0aGFuIHN1YmNsYXNzaW5nIFdlYkZyYW1lSW1wbCwgSSB3b3Vs ZCBwcmVmZXIgdG8gZGVjb3JhdGUKKyAgICAvLyBXZWJGcmFtZUNsaWVudC4gSG93ZXZlciwgc2lu Y2UgdGhhdCBpcyBub3QgYSBwdXJlIHZpcnR1YWwgaW50ZXJmYWNlLCB0aGlzCisgICAgLy8gd291 bGQgYmUgYSBtYWludGVuYW5jZSBuaWdodG1hcmUuIEknbSBvcGVuIHRvIGlkZWFzLgorICAgIG1f d2ViRnJhbWUgPSBIZWxwZXJQbHVnaW5XZWJGcmFtZTo6Y3JlYXRlKGNsaWVudCk7CisgICAgbV93 ZWJGcmFtZS0+aW5pdGlhbGl6ZUFzTWFpbkZyYW1lKG1fcGFnZS5nZXQoKSk7Cit9CisKK1dlYlBs dWdpbiogV2ViSGVscGVyUGx1Z2luSW1wbDo6Z2V0UGx1Z2luKCkKK3sKKyAgICBBU1NFUlQobV93 ZWJGcmFtZSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PEhlbHBlclBsdWdpbldlYkZyYW1lKj4o bV93ZWJGcmFtZS5nZXQoKSktPmdldFBsdWdpbigpOwogfQogCiBib29sIFdlYkhlbHBlclBsdWdp bkltcGw6OmluaXRQYWdlKFdlYktpdDo6V2ViVmlld0ltcGwqIHdlYlZpZXcsIGNvbnN0IFN0cmlu ZyYgcGx1Z2luVHlwZSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YkhlbHBlclBsdWdpbkltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhlbHBl clBsdWdpbkltcGwuaAppbmRleCA2YmRkMzM1MmYxMWYyMmQ1ZWQzZTFkNDQ1MWRjMDhjMzQxOTc3 NjllLi5mMjQ4YmEyNTI2ZmIxYTc4ODU1MDRhM2IzZGQyZjdlYTgzZWMzNTMxIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmgKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5oCkBAIC02MCw2 ICs2MCw3IEBAIHB1YmxpYzoKIAogICAgIC8vIFdlYkhlbHBlclBsdWdpbiBtZXRob2RzOgogICAg IHZpcnR1YWwgdm9pZCBpbml0aWFsaXplRnJhbWUoV2ViRnJhbWVDbGllbnQqKSBPVkVSUklERTsK KyAgICB2aXJ0dWFsIFdlYlBsdWdpbiogZ2V0UGx1Z2luKCkgT1ZFUlJJREU7CiAKIHByaXZhdGU6 CiAgICAgZXhwbGljaXQgV2ViSGVscGVyUGx1Z2luSW1wbChXZWJXaWRnZXRDbGllbnQqKTsKQEAg LTc2LDYgKzc3LDcgQEAgcHJpdmF0ZToKICAgICBXZWJWaWV3SW1wbCogbV93ZWJWaWV3OwogICAg IE93blB0cjxXZWJDb3JlOjpQYWdlPiBtX3BhZ2U7CiAgICAgT3duUHRyPEhlbHBlclBsdWdpbkNo cm9tZUNsaWVudD4gbV9jaHJvbWVDbGllbnQ7CisgICAgUmVmUHRyPFdlYkZyYW1lSW1wbD4gbV93 ZWJGcmFtZTsKIAogICAgIGZyaWVuZCBjbGFzcyBXZWJIZWxwZXJQbHVnaW47CiAgICAgZnJpZW5k IGNsYXNzIEhlbHBlclBsdWdpbkNocm9tZUNsaWVudDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCmluZGV4IDY4MGNj OTUyODcwNGY3NzA5MDY0YmYyMDRkZmI3ZGZmMmQwN2FkNGQuLmM0NTk1NmRlNjQ0NDUxNDM2MWQw OWFhYzYzNmJjOTdiM2Y0ZTkzNWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcApAQCAtMjY4LDExICsyNjgsMTIg QEAgdm9pZCBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmtleU5lZWRlZChjb25zdCBXZWJTdHJp bmcmIGtleVN5c3RlbSwgY29uc3QgV2ViU3QKICNlbmRpZgogfQogCi12b2lkIFdlYk1lZGlhUGxh eWVyQ2xpZW50SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2lu VHlwZSwgV2ViRnJhbWUqIGZyYW1lKQorV2ViUGx1Z2luKiBXZWJNZWRpYVBsYXllckNsaWVudElt cGw6OmNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZy YW1lKiBmcmFtZSkKIHsKICAgICBBU1NFUlQoIW1faGVscGVyUGx1Z2luKTsKICAgICBXZWJWaWV3 SW1wbCogd2ViVmlldyA9IHN0YXRpY19jYXN0PFdlYlZpZXdJbXBsKj4oZnJhbWUtPnZpZXcoKSk7 CiAgICAgbV9oZWxwZXJQbHVnaW4gPSB3ZWJWaWV3LT5jcmVhdGVIZWxwZXJQbHVnaW4ocGx1Z2lu VHlwZSk7CisgICAgcmV0dXJuIG1faGVscGVyUGx1Z2luLT5nZXRQbHVnaW4oKTsKIH0KIAogdm9p ZCBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNsb3NlSGVscGVyUGx1Z2luKCkKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5o IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgK aW5kZXggNjNhNDRkNzhiZjcxZGQwMjhhMTJkYzM2NDYwMzBiYjQ1MWQ1N2I5Mi4uNDFkNzYzNGM0 OTNjMTc0YWExOTczOWNkNzZjNzVkODExNGJkYjVjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKKysrIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKQEAgLTkwLDcgKzkw LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBrZXlFcnJvcihjb25zdCBXZWJTdHJpbmcm IGtleVN5c3RlbSwgY29uc3QgV2ViU3RyaW5nJiBzZXNzaW9uSWQsIE1lZGlhS2V5RXJyb3JDb2Rl LCB1bnNpZ25lZCBzaG9ydCBzeXN0ZW1Db2RlKTsKICAgICB2aXJ0dWFsIHZvaWQga2V5TWVzc2Fn ZShjb25zdCBXZWJTdHJpbmcmIGtleVN5c3RlbSwgY29uc3QgV2ViU3RyaW5nJiBzZXNzaW9uSWQs IGNvbnN0IHVuc2lnbmVkIGNoYXIqIG1lc3NhZ2UsIHVuc2lnbmVkIG1lc3NhZ2VMZW5ndGgpOwog ICAgIHZpcnR1YWwgdm9pZCBrZXlOZWVkZWQoY29uc3QgV2ViU3RyaW5nJiBrZXlTeXN0ZW0sIGNv bnN0IFdlYlN0cmluZyYgc2Vzc2lvbklkLCBjb25zdCB1bnNpZ25lZCBjaGFyKiBpbml0RGF0YSwg dW5zaWduZWQgaW5pdERhdGFMZW5ndGgpOwotICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVIZWxwZXJQ bHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSopOworICAgIHZpcnR1 YWwgV2ViUGx1Z2luKiBjcmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5U eXBlLCBXZWJGcmFtZSopOwogICAgIHZpcnR1YWwgdm9pZCBjbG9zZUhlbHBlclBsdWdpbigpOwog ICAgIHZpcnR1YWwgdm9pZCBkaXNhYmxlQWNjZWxlcmF0ZWRDb21wb3NpdGluZygpOwogCg== 145385 2012-06-01 15:02:47 -0700 2012-06-01 15:23:23 -0700 Shows possible decorator solution and alternate m_plugin lifetime. Does not compile. bug-88028-20120601150246.patch text/plain 10331 ddorwin ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggM2RjZjM3MzFjMTZjMTRiMmJjNDA3YmM1YWEw OGMwYWZjNTE2Y2M5MS4uYzkyOWZlMTI4NjFiYjE3ZTU0NTEzMWRiNTZlNTc3MzU2YTI0YzNmZiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNCBAQAorMjAxMi0wNi0wMSAg RGF2aWQgRG9yd2luICA8ZGRvcndpbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV0dXJuIGEg cG9pbnRlciB0byB0aGUgV2ViUGx1Z2luIGNyZWF0ZWQgYnkgY3JlYXRlSGVscGVyUGx1Z2luKCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4MDI4CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQSBXZWJQbHVn aW4gaXMgY3JlYXRlZCB3aGVuIHRoZSBkb2N1bWVudCBjcmVhdGVkIGJ5IGNyZWF0ZUhlbHBlclBs dWdpbigpIGlzIGxheWVkIG91dC4KKyAgICAgICAgUmV0dXJuIGl0IHRvIHRoZSBjYWxsZXIgc28g dGhhdCBpdCBjYW4gaW50ZXJhY3Qgd2l0aCB0aGUgcGx1Z2luIGluc3RhbmNlLgorCisgICAgICAg ICogcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50Lmg6CisgICAgICAgIChXZWJLaXQpOgorICAg ICAgICAqIHNyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcDoKKyAgICAgICAgKEhlbHBlclBsdWdp bldlYkZyYW1lQ2xpZW50KToKKyAgICAgICAgKFdlYktpdDo6SGVscGVyUGx1Z2luV2ViRnJhbWVD bGllbnQ6OkhlbHBlclBsdWdpbldlYkZyYW1lKToKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAg IChXZWJLaXQ6OldlYkhlbHBlclBsdWdpbkltcGw6OldlYkhlbHBlclBsdWdpbkltcGwpOgorICAg ICAgICAoV2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjp+V2ViSGVscGVyUGx1Z2luSW1wbCk6 CisgICAgICAgIChXZWJLaXQ6OldlYkhlbHBlclBsdWdpbkltcGw6OmluaXQpOgorICAgICAgICAo V2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0aWFsaXplRnJhbWUpOgorICAgICAgICAo V2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjpzZXRQbHVnaW4pOgorICAgICAgICAqIHNyYy9X ZWJIZWxwZXJQbHVnaW5JbXBsLmg6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViSGVs cGVyUGx1Z2luSW1wbCk6CisgICAgICAgICogc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6Y3JlYXRlSGVs cGVyUGx1Z2luKToKKyAgICAgICAgKiBzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmg6Cisg ICAgICAgIChXZWJNZWRpYVBsYXllckNsaWVudEltcGwpOgorICAgICAgICAqIHNyYy9XZWJWaWV3 SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBsOjpjcmVhdGVIZWxwZXJQbHVn aW4pOgorCiAyMDEyLTA1LTMwICBEYXZpZCBEb3J3aW4gIDxkZG9yd2luQGNocm9taXVtLm9yZz4K IAogICAgICAgICBFbmFibGUgQ2hyb21pdW0gbWVkaWEgcGxheWVyIHRvIGluc3RhbnRpYXRlIGEg cGx1Z2luCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRp YVBsYXllckNsaWVudC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQ bGF5ZXJDbGllbnQuaAppbmRleCBhNDZlZTVjZWQ0OGFjOWY1ODVmYzFkZGQyNGZhMDIyMTgyYjRl MTk4Li5lMzEyNmE1MDk2M2YxMTIwODM2NDkxMDYxZDYzYjI0MWY0MDYwMzEzIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50LmgK QEAgLTM2LDYgKzM2LDcgQEAKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJGcmFtZTsK K2NsYXNzIFdlYlBsdWdpbjsKIGNsYXNzIFdlYlJlcXVlc3Q7CiBjbGFzcyBXZWJVUkw7CiAKQEAg LTc2LDcgKzc3LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBrZXlFcnJvcihjb25zdCBX ZWJTdHJpbmcmLCBjb25zdCBXZWJTdHJpbmcmLCBNZWRpYUtleUVycm9yQ29kZSwgdW5zaWduZWQg c2hvcnQgc3lzdGVtQ29kZSkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBrZXlNZXNzYWdlKGNvbnN0 IFdlYlN0cmluZyYsIGNvbnN0IFdlYlN0cmluZyYsIGNvbnN0IHVuc2lnbmVkIGNoYXIqLCB1bnNp Z25lZCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBrZXlOZWVkZWQoY29uc3QgV2ViU3RyaW5nJiwg Y29uc3QgV2ViU3RyaW5nJiwgY29uc3QgdW5zaWduZWQgY2hhciogaW5pdERhdGEsIHVuc2lnbmVk IGluaXREYXRhTGVuZ3RoKSA9IDA7Ci0gICAgdmlydHVhbCB2b2lkIGNyZWF0ZUhlbHBlclBsdWdp bihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKikgPSAwOworICAgIC8vIFRo ZSByZXR1cm5lZCBwb2ludGVyIGlzIG9ubHkgZ3VhcmFudGVlZCB0byBiZSB2YWxpZCBpbiB0aGlz IGNhbGwgc3RhY2suCisgICAgdmlydHVhbCBXZWJQbHVnaW4qIGNyZWF0ZUhlbHBlclBsdWdpbihj b25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKikgPSAwOwogICAgIHZpcnR1YWwg dm9pZCBjbG9zZUhlbHBlclBsdWdpbigpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQgZGlzYWJsZUFj Y2VsZXJhdGVkQ29tcG9zaXRpbmcoKSA9IDA7CiBwcm90ZWN0ZWQ6CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcCBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhlbHBlclBsdWdpbkltcGwuY3BwCmluZGV4IGMxMGYxMmVj MDY0ZTcxNzhhOTU1MmNiZTYxZDk1YTc5OTFjN2U5ODYuLmU5YmNjYWE4ZjIxYzQzNWMzNTAyZTcz ZDk0YTNhZGMwYTA3Y2ZiNzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkhlbHBlclBsdWdpbkltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkhlbHBlclBsdWdpbkltcGwuY3BwCkBAIC05MywzMiArOTMsNjQgQEAgcHJpdmF0ZToKICAg ICBXZWJIZWxwZXJQbHVnaW5JbXBsKiBtX3dpZGdldDsKIH07CiAKK2NsYXNzIEhlbHBlclBsdWdp bldlYkZyYW1lQ2xpZW50IDogcHVibGljIFdlYkZyYW1lQ2xpZW50RGVjb3JhdG9yIHsKK3B1Ymxp YzoKKyAgICB2aXJ0dWFsIFdlYlBsdWdpbiogY3JlYXRlUGx1Z2luKFdlYkZyYW1lKiBmcmFtZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFdlYlBsdWdpblBhcmFt cyYgcGFyYW1zKSBPVkVSUklERQorICAgIHsKKyAgICAgICAgcGx1Z2luID0gV2ViRnJhbWVDbGll bnREZWNvcmF0b3I6OmNyZWF0ZVBsdWdpbihmcmFtZSwgcGFyYW1zKTsKKyAgICAgICAgbV9oZWxw ZXJQbHVnaW4tPnNldFBsdWdpbihwbHVnaW4pCisgICAgICAgIHJldHVybiBwbHVnaW47CisgICAg fQorCisgICAgSGVscGVyUGx1Z2luV2ViRnJhbWUoV2ViRnJhbWVDbGllbnQqIGRlY29yYXRlZFdl YkZyYW1lQ2xpZW50KiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBXZWJIZWxwZXJQbHVnaW5J bXBsKiBoZWxwZXJQbHVnaW4pCisgICAgICAgIDogV2ViRnJhbWVDbGllbnREZWNvcmF0b3IoZGVj b3JhdGVkV2ViRnJhbWVDbGllbnQpCisgICAgICAgICwgbV9oZWxwZXJQbHVnaW4oV2ViSGVscGVy UGx1Z2luSW1wbCkgeyB9CisKKyAgICBXZWJIZWxwZXJQbHVnaW5JbXBsKiBtX2hlbHBlclBsdWdp bjsKK307CisKKwogLy8gV2ViSGVscGVyUGx1Z2luSW1wbCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFdlYkhlbHBlclBs dWdpbkltcGw6OldlYkhlbHBlclBsdWdpbkltcGwoV2ViV2lkZ2V0Q2xpZW50KiBjbGllbnQpCiAg ICAgOiBtX3dpZGdldENsaWVudChjbGllbnQpCiAgICAgLCBtX3dlYlZpZXcoMCkKKyAgICAsIG1f cGx1Z2luKDApCiB7CiAgICAgQVNTRVJUKGNsaWVudCk7CiB9CiAKKy8vIERlc3Ryb3lzIHRoZSBI ZWxwZXJQbHVnaW5XZWJGcmFtZUNsaWVudCBpZiBvbmUgd2FzIGNyZWF0ZWQuCisvLyBUaGUgZGVj b3JhdGVkIFdlYkZyYW1lQ2xpZW50IGlzIG5vdCBkZXN0cm95ZWQuCisvLyBEZXN0cm95IHRoZSBX ZWJGcmFtZSBiZWZvcmUgdGhlIFdlYkZyYW1lQ2xpZW50IHRvIGJlIHNhZmUuCiBXZWJIZWxwZXJQ bHVnaW5JbXBsOjp+V2ViSGVscGVyUGx1Z2luSW1wbCgpCiB7CiAgICAgQVNTRVJUKCFtX3BhZ2Up OworICAgIGlmIChtX3dlYkZyYW1lKSB7CisgICAgICAgIFdlYkZyYW1lQ2xpZW50KiB3ZWJGcmFt ZUNsaWVudCA9IG1fd2ViRnJhbWUtPmNsaWVudCgpOworICAgICAgICBtX3dlYkZyYW1lLnJlc2V0 KCk7CisgICAgICAgIGRlbGV0ZSB3ZWJGcmFtZUNsaWVudDsKKyAgICB9CiB9CiAKLWJvb2wgV2Vi SGVscGVyUGx1Z2luSW1wbDo6aW5pdChXZWJWaWV3SW1wbCogd2ViVmlldywgY29uc3QgU3RyaW5n JiBwbHVnaW5UeXBlKQorV2ViUGx1Z2luKiBXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0KFdlYlZp ZXdJbXBsKiB3ZWJWaWV3LCBjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUpCiB7CisgICAgQVNTRVJU KCFtX3BsdWdpbik7CiAgICAgQVNTRVJUKHdlYlZpZXcpOwogICAgIG1fd2ViVmlldyA9IHdlYlZp ZXc7CiAKICAgICBpZiAoIWluaXRQYWdlKHdlYlZpZXcsIHBsdWdpblR5cGUpKQotICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgICAgIHJldHVybiAwOwogICAgIG1fd2lkZ2V0Q2xpZW50LT5zaG93 KFdlYk5hdmlnYXRpb25Qb2xpY3koKSk7CiAKICAgICBzZXRGb2N1cyh0cnVlKTsKIAotICAgIHJl dHVybiB0cnVlOworICAgIEFTU0VSVChtX3BsdWdpbik7CisgICAgV2ViUGx1Z2luKiBwbHVnaW4g PSBtX3BsdWdpbjsKKyAgICBtX3BsdWdpbiA9IDA7IC8vIENsZWFyIHRoZSBwb2ludGVyIHNpbmNl IGl0IGlzIG5vdCBndWFyYW50ZWVkIHRvIGJlIHZhbGlkLgorICAgIHJldHVybiBwbHVnaW47CiB9 CiAKIHZvaWQgV2ViSGVscGVyUGx1Z2luSW1wbDo6Y2xvc2VIZWxwZXJQbHVnaW4oKQpAQCAtMTM4 LDggKzE3MCwxNSBAQCB2b2lkIFdlYkhlbHBlclBsdWdpbkltcGw6OmNsb3NlSGVscGVyUGx1Z2lu KCkKIHZvaWQgV2ViSGVscGVyUGx1Z2luSW1wbDo6aW5pdGlhbGl6ZUZyYW1lKFdlYkZyYW1lQ2xp ZW50KiBjbGllbnQpCiB7CiAgICAgQVNTRVJUKG1fcGFnZSk7Ci0gICAgUmVmUHRyPFdlYkZyYW1l SW1wbD4gZnJhbWUgPSBXZWJGcmFtZUltcGw6OmNyZWF0ZShjbGllbnQpOwotICAgIGZyYW1lLT5p bml0aWFsaXplQXNNYWluRnJhbWUobV9wYWdlLmdldCgpKTsKKyAgICBXZWJGcmFtZUNsaWVudCog ZGVjb3JhdGVkQ2xpZW50ID0gbmV3IEhlbHBlclBsdWdpbldlYkZyYW1lQ2xpZW50KGNsaWVudCwg dGhpcykKKyAgICBtX3dlYkZyYW1lID0gV2ViRnJhbWVJbXBsOjpjcmVhdGUoZGVjb3JhdGVkQ2xp ZW50KTsKKyAgICBtX3dlYkZyYW1lLT5pbml0aWFsaXplQXNNYWluRnJhbWUobV9wYWdlLmdldCgp KTsKK30KKwordm9pZCBXZWJIZWxwZXJQbHVnaW5JbXBsOjpzZXRQbHVnaW4oV2ViUGx1Z2luKiBw bHVnaW4pCit7CisgICAgQVNTRVJUKCFtX3BsdWdpbik7CisgICAgbV9wbHVnaW4gPSBwbHVnaW47 CiB9CiAKIGJvb2wgV2ViSGVscGVyUGx1Z2luSW1wbDo6aW5pdFBhZ2UoV2ViS2l0OjpXZWJWaWV3 SW1wbCogd2ViVmlldywgY29uc3QgU3RyaW5nJiBwbHVnaW5UeXBlKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5oIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5oCmluZGV4IDZiZGQzMzUyZjEx ZjIyZDVlZDNlMWQ0NDUxZGMwOGMzNDE5Nzc2OWUuLmNjNjdmM2QzMzA1Y2Q3YmQxOGI4ZjM4MThh NGMxNTUwMGVlMDVlNmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dl YkhlbHBlclBsdWdpbkltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJI ZWxwZXJQbHVnaW5JbXBsLmgKQEAgLTQzLDYgKzQzLDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAK IGNsYXNzIEhlbHBlclBsdWdpbkNocm9tZUNsaWVudDsKIGNsYXNzIFdlYkZyYW1lSW1wbDsKK2Ns YXNzIEhlbHBlclBsdWdpbldlYkZyYW1lQ2xpZW50OwogY2xhc3MgV2ViVmlld0ltcGw7CiBjbGFz cyBXZWJXaWRnZXRDbGllbnQ7CiAKQEAgLTU1LDcgKzU2LDcgQEAgY2xhc3MgV2ViSGVscGVyUGx1 Z2luSW1wbCA6IHB1YmxpYyBXZWJIZWxwZXJQbHVnaW4sCiAKIHB1YmxpYzoKICAgICB2aXJ0dWFs IH5XZWJIZWxwZXJQbHVnaW5JbXBsKCk7Ci0gICAgYm9vbCBpbml0KFdlYlZpZXdJbXBsKiwgY29u c3QgU3RyaW5nJiBwbHVnaW5UeXBlKTsKKyAgICBXZWJQbHVnaW4qIGluaXQoV2ViVmlld0ltcGwq LCBjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUpOwogICAgIHZvaWQgY2xvc2VIZWxwZXJQbHVnaW4o KTsKIAogICAgIC8vIFdlYkhlbHBlclBsdWdpbiBtZXRob2RzOgpAQCAtNjQsNiArNjUsNyBAQCBw dWJsaWM6CiBwcml2YXRlOgogICAgIGV4cGxpY2l0IFdlYkhlbHBlclBsdWdpbkltcGwoV2ViV2lk Z2V0Q2xpZW50Kik7CiAgICAgYm9vbCBpbml0UGFnZShXZWJLaXQ6OldlYlZpZXdJbXBsKiwgY29u c3QgU3RyaW5nJiBwbHVnaW5UeXBlKTsKKyAgICB2b2lkIHNldFBsdWdpbihXZWJQbHVnaW4qKTsK IAogICAgIC8vIFdlYldpZGdldCBtZXRob2RzOgogICAgIHZpcnR1YWwgdm9pZCBzZXRDb21wb3Np dG9yU3VyZmFjZVJlYWR5KCkgT1ZFUlJJREU7CkBAIC03Niw5ICs3OCwxMiBAQCBwcml2YXRlOgog ICAgIFdlYlZpZXdJbXBsKiBtX3dlYlZpZXc7CiAgICAgT3duUHRyPFdlYkNvcmU6OlBhZ2U+IG1f cGFnZTsKICAgICBPd25QdHI8SGVscGVyUGx1Z2luQ2hyb21lQ2xpZW50PiBtX2Nocm9tZUNsaWVu dDsKKyAgICBSZWZQdHI8V2ViRnJhbWVJbXBsPiBtX3dlYkZyYW1lOworICAgIFdlYlBsdWdpbiog bV9wbHVnaW47IC8vIE9ubHkgdmFsaWQgZHVyaW5nIGluaXQoKS4KIAogICAgIGZyaWVuZCBjbGFz cyBXZWJIZWxwZXJQbHVnaW47CiAgICAgZnJpZW5kIGNsYXNzIEhlbHBlclBsdWdpbkNocm9tZUNs aWVudDsKKyAgICBmcmllbmQgY2xhc3MgSGVscGVyUGx1Z2luV2ViRnJhbWVDbGllbnQ7CiB9Owog CiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCmluZGV4IDY4MGNjOTUyODcwNGY3 NzA5MDY0YmYyMDRkZmI3ZGZmMmQwN2FkNGQuLjgyYTE3NDBjYmQ2ZDQ0NzJlNDBiYzg3ZjEzMjI2 NjI3N2UzYzNjYmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1l ZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcApAQCAtMjY4LDExICsyNjgsMTMgQEAgdm9pZCBX ZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmtleU5lZWRlZChjb25zdCBXZWJTdHJpbmcmIGtleVN5 c3RlbSwgY29uc3QgV2ViU3QKICNlbmRpZgogfQogCi12b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50 SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2luVHlwZSwgV2Vi RnJhbWUqIGZyYW1lKQorV2ViUGx1Z2luKiBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNyZWF0 ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKiBmcmFt ZSkKIHsKICAgICBBU1NFUlQoIW1faGVscGVyUGx1Z2luKTsKICAgICBXZWJWaWV3SW1wbCogd2Vi VmlldyA9IHN0YXRpY19jYXN0PFdlYlZpZXdJbXBsKj4oZnJhbWUtPnZpZXcoKSk7Ci0gICAgbV9o ZWxwZXJQbHVnaW4gPSB3ZWJWaWV3LT5jcmVhdGVIZWxwZXJQbHVnaW4ocGx1Z2luVHlwZSk7Cisg ICAgV2ViUGx1Z2luKiBwbHVnaW4gPSAwOworICAgIG1faGVscGVyUGx1Z2luID0gd2ViVmlldy0+ Y3JlYXRlSGVscGVyUGx1Z2luKHBsdWdpblR5cGUsICZwbHVnaW4pOworICAgIHJldHVybiBwbHVn aW47CiB9CiAKIHZvaWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpjbG9zZUhlbHBlclBsdWdp bigpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXll ckNsaWVudEltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVy Q2xpZW50SW1wbC5oCmluZGV4IDYzYTQ0ZDc4YmY3MWRkMDI4YTEyZGMzNjQ2MDMwYmI0NTFkNTdi OTIuLjQxZDc2MzRjNDkzYzE3NGFhMTk3MzljZDc2Yzc1ZDgxMTRiZGI1YzAgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5o CkBAIC05MCw3ICs5MCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQga2V5RXJyb3IoY29u c3QgV2ViU3RyaW5nJiBrZXlTeXN0ZW0sIGNvbnN0IFdlYlN0cmluZyYgc2Vzc2lvbklkLCBNZWRp YUtleUVycm9yQ29kZSwgdW5zaWduZWQgc2hvcnQgc3lzdGVtQ29kZSk7CiAgICAgdmlydHVhbCB2 b2lkIGtleU1lc3NhZ2UoY29uc3QgV2ViU3RyaW5nJiBrZXlTeXN0ZW0sIGNvbnN0IFdlYlN0cmlu ZyYgc2Vzc2lvbklkLCBjb25zdCB1bnNpZ25lZCBjaGFyKiBtZXNzYWdlLCB1bnNpZ25lZCBtZXNz YWdlTGVuZ3RoKTsKICAgICB2aXJ0dWFsIHZvaWQga2V5TmVlZGVkKGNvbnN0IFdlYlN0cmluZyYg a2V5U3lzdGVtLCBjb25zdCBXZWJTdHJpbmcmIHNlc3Npb25JZCwgY29uc3QgdW5zaWduZWQgY2hh ciogaW5pdERhdGEsIHVuc2lnbmVkIGluaXREYXRhTGVuZ3RoKTsKLSAgICB2aXJ0dWFsIHZvaWQg Y3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUq KTsKKyAgICB2aXJ0dWFsIFdlYlBsdWdpbiogY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0 cmluZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUqKTsKICAgICB2aXJ0dWFsIHZvaWQgY2xvc2VIZWxw ZXJQbHVnaW4oKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlzYWJsZUFjY2VsZXJhdGVkQ29tcG9zaXRp bmcoKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0lt cGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4 IDNlNGU5ZjAxNmZkNmQ3MzcwYTZhZDU4ZmEzNTVlMWFhN2Y0ODk5N2IuLjdmOGZkMGZmNmQ1YTg2 OTkxZTdlYzVmMWJjNzBmYjAwYjczNDExYjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJWaWV3SW1wbC5jcHAKQEAgLTEyNzEsMTMgKzEyNzEsMTUgQEAgdm9pZCBXZWJWaWV3SW1w bDo6aGlkZUF1dG9maWxsUG9wdXAoKQogICAgIH0KIH0KIAotV2ViSGVscGVyUGx1Z2luSW1wbCog V2ViVmlld0ltcGw6OmNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUp CitXZWJIZWxwZXJQbHVnaW5JbXBsKiBXZWJWaWV3SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKGNv bnN0IFN0cmluZyYgcGx1Z2luVHlwZSwgV2ViUGx1Z2luKiogcGx1Z2luKQogeworICAgIEFTU0VS VChwbHVnaW4pOwogICAgIFdlYldpZGdldCogcG9wdXBXaWRnZXQgPSBtX2NsaWVudC0+Y3JlYXRl UG9wdXBNZW51KFdlYlBvcHVwVHlwZUhlbHBlclBsdWdpbik7CiAgICAgQVNTRVJUKHBvcHVwV2lk Z2V0KTsKICAgICBXZWJIZWxwZXJQbHVnaW5JbXBsKiBoZWxwZXJQbHVnaW4gPSBzdGF0aWNfY2Fz dDxXZWJIZWxwZXJQbHVnaW5JbXBsKj4ocG9wdXBXaWRnZXQpOwogCi0gICAgaWYgKCFoZWxwZXJQ bHVnaW4tPmluaXQodGhpcywgcGx1Z2luVHlwZSkpIHsKKyAgICAqcGx1Z2luID0gaGVscGVyUGx1 Z2luLT5pbml0KHRoaXMsIHBsdWdpblR5cGUpOworICAgIGlmICghKnBsdWdpbikgewogICAgICAg ICBoZWxwZXJQbHVnaW4tPmNsb3NlSGVscGVyUGx1Z2luKCk7CiAgICAgICAgIGhlbHBlclBsdWdp biA9IDA7CiAgICAgfQo= 145391 2012-06-01 15:34:11 -0700 2012-06-06 18:38:07 -0700 Shows possible decorator solution and alternate m_plugin lifetime. Would compile with addition of WebFrameClientDecorator. bug-88028-20120601153410.patch text/plain 12032 ddorwin ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggM2RjZjM3MzFjMTZjMTRiMmJjNDA3YmM1YWEw OGMwYWZjNTE2Y2M5MS4uNTQ4YjQ5ZTAwNjgxZTI0OTMwMGNiZWQ5ZTU1OWUxMTdhOWIyMjA5YyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOCBAQAorMjAxMi0wNi0wMSAg RGF2aWQgRG9yd2luICA8ZGRvcndpbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV0dXJuIGEg cG9pbnRlciB0byB0aGUgV2ViUGx1Z2luIGNyZWF0ZWQgYnkgY3JlYXRlSGVscGVyUGx1Z2luKCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4MDI4CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQSBXZWJQbHVn aW4gaXMgY3JlYXRlZCB3aGVuIHRoZSBkb2N1bWVudCBjcmVhdGVkIGJ5IGNyZWF0ZUhlbHBlclBs dWdpbigpIGlzIGxheWVkIG91dC4KKyAgICAgICAgUmV0dXJuIGl0IHRvIHRoZSBjYWxsZXIgc28g dGhhdCBpdCBjYW4gaW50ZXJhY3Qgd2l0aCB0aGUgcGx1Z2luIGluc3RhbmNlLgorCisgICAgICAg ICogcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50Lmg6CisgICAgICAgIChXZWJLaXQpOgorICAg ICAgICAqIHNyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdCk6Cisg ICAgICAgIChIZWxwZXJQbHVnaW5XZWJGcmFtZUNsaWVudCk6CisgICAgICAgIChXZWJLaXQ6Okhl bHBlclBsdWdpbldlYkZyYW1lQ2xpZW50OjpIZWxwZXJQbHVnaW5XZWJGcmFtZUNsaWVudCk6Cisg ICAgICAgIChXZWJLaXQ6OkhlbHBlclBsdWdpbldlYkZyYW1lQ2xpZW50Ojp+SGVscGVyUGx1Z2lu V2ViRnJhbWVDbGllbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjpX ZWJIZWxwZXJQbHVnaW5JbXBsKToKKyAgICAgICAgKFdlYktpdDo6V2ViSGVscGVyUGx1Z2luSW1w bDo6fldlYkhlbHBlclBsdWdpbkltcGwpOgorICAgICAgICAoV2ViS2l0OjpXZWJIZWxwZXJQbHVn aW5JbXBsOjppbml0KToKKyAgICAgICAgKFdlYktpdDo6V2ViSGVscGVyUGx1Z2luSW1wbDo6aW5p dGlhbGl6ZUZyYW1lKToKKyAgICAgICAgKFdlYktpdDo6V2ViSGVscGVyUGx1Z2luSW1wbDo6c2V0 UGx1Z2luKToKKyAgICAgICAgKiBzcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5oOgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYkhlbHBlclBsdWdpbkltcGwpOgorICAgICAgICAqIHNyYy9X ZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJNZWRpYVBs YXllckNsaWVudEltcGw6OmNyZWF0ZUhlbHBlclBsdWdpbik6CisgICAgICAgICogc3JjL1dlYk1l ZGlhUGxheWVyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBs KToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJW aWV3SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwu aDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJWaWV3SW1wbCk6CisKIDIwMTItMDUt MzAgIERhdmlkIERvcndpbiAgPGRkb3J3aW5AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIEVuYWJs ZSBDaHJvbWl1bSBtZWRpYSBwbGF5ZXIgdG8gaW5zdGFudGlhdGUgYSBwbHVnaW4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50Lmgg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oCmlu ZGV4IGE0NmVlNWNlZDQ4YWM5ZjU4NWZjMWRkZDI0ZmEwMjIxODJiNGUxOTguLmUzMTI2YTUwOTYz ZjExMjA4MzY0OTEwNjFkNjNiMjQxZjQwNjAzMTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXJDbGllbnQuaApAQCAtMzYsNiArMzYsNyBA QAogbmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYkZyYW1lOworY2xhc3MgV2ViUGx1Z2lu OwogY2xhc3MgV2ViUmVxdWVzdDsKIGNsYXNzIFdlYlVSTDsKIApAQCAtNzYsNyArNzcsOCBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGtleUVycm9yKGNvbnN0IFdlYlN0cmluZyYsIGNvbnN0 IFdlYlN0cmluZyYsIE1lZGlhS2V5RXJyb3JDb2RlLCB1bnNpZ25lZCBzaG9ydCBzeXN0ZW1Db2Rl KSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGtleU1lc3NhZ2UoY29uc3QgV2ViU3RyaW5nJiwgY29u c3QgV2ViU3RyaW5nJiwgY29uc3QgdW5zaWduZWQgY2hhciosIHVuc2lnbmVkKSA9IDA7CiAgICAg dmlydHVhbCB2b2lkIGtleU5lZWRlZChjb25zdCBXZWJTdHJpbmcmLCBjb25zdCBXZWJTdHJpbmcm LCBjb25zdCB1bnNpZ25lZCBjaGFyKiBpbml0RGF0YSwgdW5zaWduZWQgaW5pdERhdGFMZW5ndGgp ID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmlu ZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUqKSA9IDA7CisgICAgLy8gVGhlIHJldHVybmVkIHBvaW50 ZXIgaXMgb25seSBndWFyYW50ZWVkIHRvIGJlIHZhbGlkIGluIHRoaXMgY2FsbCBzdGFjay4KKyAg ICB2aXJ0dWFsIFdlYlBsdWdpbiogY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYg cGx1Z2luVHlwZSwgV2ViRnJhbWUqKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGNsb3NlSGVscGVy UGx1Z2luKCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBkaXNhYmxlQWNjZWxlcmF0ZWRDb21wb3Np dGluZygpID0gMDsKIHByb3RlY3RlZDoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYkhlbHBlclBsdWdpbkltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViSGVscGVyUGx1Z2luSW1wbC5jcHAKaW5kZXggYzEwZjEyZWMwNjRlNzE3OGE5NTUyY2Jl NjFkOTVhNzk5MWM3ZTk4Ni4uZWViMDY1OWZjYTAzMjk1MmZjYzk0M2U5OWRhN2JmYzM1MTNhNjIx ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2lu SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2lu SW1wbC5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAi UGFnZVdpZGdldERlbGVnYXRlLmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKKyNpbmNsdWRlICJX ZWJGcmFtZUNsaWVudERlY29yYXRvci5oIiAvLyBGSVhNRTogRG9lcyBub3QgZXhpc3QhCiAjaW5j bHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViVmlld0NsaWVudC5oIgogI2luY2x1 ZGUgIldlYlZpZXdJbXBsLmgiCkBAIC00Niw2ICs0Nyw4IEBAIHVzaW5nIG5hbWVzcGFjZSBXZWJD b3JlOwogCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAorc3RydWN0IFdlYlBsdWdpblBhcmFtczsKKwog I2RlZmluZSBhZGRMaXRlcmFsKGxpdGVyYWwsIHdyaXRlcikgICAgd3JpdGVyLmFkZERhdGEobGl0 ZXJhbCwgc2l6ZW9mKGxpdGVyYWwpIC0gMSkKIAogc3RhdGljIGlubGluZSB2b2lkIGFkZFN0cmlu Zyhjb25zdCBTdHJpbmcmIHN0ciwgRG9jdW1lbnRXcml0ZXImIHdyaXRlcikKQEAgLTkzLDMyICs5 Niw2OSBAQCBwcml2YXRlOgogICAgIFdlYkhlbHBlclBsdWdpbkltcGwqIG1fd2lkZ2V0OwogfTsK IAorY2xhc3MgSGVscGVyUGx1Z2luV2ViRnJhbWVDbGllbnQgOiBwdWJsaWMgV2ViRnJhbWVDbGll bnREZWNvcmF0b3IgeworcHVibGljOgorICAgIHZpcnR1YWwgV2ViUGx1Z2luKiBjcmVhdGVQbHVn aW4oV2ViRnJhbWUqIGZyYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29uc3QgV2ViUGx1Z2luUGFyYW1zJiBwYXJhbXMpIE9WRVJSSURFCisgICAgeworICAgICAgICBX ZWJQbHVnaW4qIHBsdWdpbiA9CisgICAgICAgICAgICBXZWJGcmFtZUNsaWVudERlY29yYXRvcjo6 Y3JlYXRlUGx1Z2luKGZyYW1lLCBwYXJhbXMpOworICAgICAgICBtX2hlbHBlclBsdWdpbi0+c2V0 UGx1Z2luKHBsdWdpbik7CisgICAgICAgIHJldHVybiBwbHVnaW47CisgICAgfQorCisgICAgSGVs cGVyUGx1Z2luV2ViRnJhbWVDbGllbnQoV2ViRnJhbWVDbGllbnQqIGRlY29yYXRlZFdlYkZyYW1l Q2xpZW50LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdlYkhlbHBlclBsdWdpbklt cGwqIGhlbHBlclBsdWdpbikKKyAgICAgICAgOiBXZWJGcmFtZUNsaWVudERlY29yYXRvcihkZWNv cmF0ZWRXZWJGcmFtZUNsaWVudCkKKyAgICAgICAgLCBtX2hlbHBlclBsdWdpbihoZWxwZXJQbHVn aW4pIHsgfQorCisgICAgdmlydHVhbCB+SGVscGVyUGx1Z2luV2ViRnJhbWVDbGllbnQoKSB7IH0K KworcHJpdmF0ZToKKyAgICBXZWJIZWxwZXJQbHVnaW5JbXBsKiBtX2hlbHBlclBsdWdpbjsKK307 CisKKwogLy8gV2ViSGVscGVyUGx1Z2luSW1wbCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFdlYkhlbHBlclBsdWdpbklt cGw6OldlYkhlbHBlclBsdWdpbkltcGwoV2ViV2lkZ2V0Q2xpZW50KiBjbGllbnQpCiAgICAgOiBt X3dpZGdldENsaWVudChjbGllbnQpCiAgICAgLCBtX3dlYlZpZXcoMCkKKyAgICAsIG1fcGx1Z2lu KDApCiB7CiAgICAgQVNTRVJUKGNsaWVudCk7CiB9CiAKKy8vIERlc3Ryb3lzIHRoZSBIZWxwZXJQ bHVnaW5XZWJGcmFtZUNsaWVudCBpZiBvbmUgd2FzIGNyZWF0ZWQuCisvLyBUaGUgZGVjb3JhdGVk IFdlYkZyYW1lQ2xpZW50IGlzIG5vdCBkZXN0cm95ZWQuCisvLyBEZXN0cm95IHRoZSBXZWJGcmFt ZSBiZWZvcmUgdGhlIFdlYkZyYW1lQ2xpZW50IHRvIGJlIHNhZmUuCiBXZWJIZWxwZXJQbHVnaW5J bXBsOjp+V2ViSGVscGVyUGx1Z2luSW1wbCgpCiB7CiAgICAgQVNTRVJUKCFtX3BhZ2UpOworICAg IGlmIChtX3dlYkZyYW1lKSB7CisgICAgICAgIEhlbHBlclBsdWdpbldlYkZyYW1lQ2xpZW50KiB3 ZWJGcmFtZUNsaWVudCA9CisgICAgICAgICAgICBzdGF0aWNfY2FzdDxIZWxwZXJQbHVnaW5XZWJG cmFtZUNsaWVudCo+KG1fd2ViRnJhbWUtPmNsaWVudCgpKTsKKyAgICAgICAgbV93ZWJGcmFtZS5j bGVhcigpOworICAgICAgICBkZWxldGUgd2ViRnJhbWVDbGllbnQ7CisgICAgfQogfQogCi1ib29s IFdlYkhlbHBlclBsdWdpbkltcGw6OmluaXQoV2ViVmlld0ltcGwqIHdlYlZpZXcsIGNvbnN0IFN0 cmluZyYgcGx1Z2luVHlwZSkKK1dlYlBsdWdpbiogV2ViSGVscGVyUGx1Z2luSW1wbDo6aW5pdChX ZWJWaWV3SW1wbCogd2ViVmlldywgY29uc3QgU3RyaW5nJiBwbHVnaW5UeXBlKQogeworICAgIEFT U0VSVCghbV9wbHVnaW4pOwogICAgIEFTU0VSVCh3ZWJWaWV3KTsKICAgICBtX3dlYlZpZXcgPSB3 ZWJWaWV3OwogCiAgICAgaWYgKCFpbml0UGFnZSh3ZWJWaWV3LCBwbHVnaW5UeXBlKSkKLSAgICAg ICAgcmV0dXJuIGZhbHNlOworICAgICAgICByZXR1cm4gMDsKICAgICBtX3dpZGdldENsaWVudC0+ c2hvdyhXZWJOYXZpZ2F0aW9uUG9saWN5KCkpOwogCiAgICAgc2V0Rm9jdXModHJ1ZSk7CiAKLSAg ICByZXR1cm4gdHJ1ZTsKKyAgICBBU1NFUlQobV9wbHVnaW4pOworICAgIFdlYlBsdWdpbiogcGx1 Z2luID0gbV9wbHVnaW47CisgICAgbV9wbHVnaW4gPSAwOyAvLyBDbGVhciB0aGUgcG9pbnRlciBz aW5jZSBpdCBpcyBub3QgZ3VhcmFudGVlZCB0byBiZSB2YWxpZC4KKyAgICByZXR1cm4gcGx1Z2lu OwogfQogCiB2b2lkIFdlYkhlbHBlclBsdWdpbkltcGw6OmNsb3NlSGVscGVyUGx1Z2luKCkKQEAg LTEzOCw4ICsxNzgsMTUgQEAgdm9pZCBXZWJIZWxwZXJQbHVnaW5JbXBsOjpjbG9zZUhlbHBlclBs dWdpbigpCiB2b2lkIFdlYkhlbHBlclBsdWdpbkltcGw6OmluaXRpYWxpemVGcmFtZShXZWJGcmFt ZUNsaWVudCogY2xpZW50KQogewogICAgIEFTU0VSVChtX3BhZ2UpOwotICAgIFJlZlB0cjxXZWJG cmFtZUltcGw+IGZyYW1lID0gV2ViRnJhbWVJbXBsOjpjcmVhdGUoY2xpZW50KTsKLSAgICBmcmFt ZS0+aW5pdGlhbGl6ZUFzTWFpbkZyYW1lKG1fcGFnZS5nZXQoKSk7CisgICAgV2ViRnJhbWVDbGll bnQqIGRlY29yYXRlZENsaWVudCA9IG5ldyBIZWxwZXJQbHVnaW5XZWJGcmFtZUNsaWVudChjbGll bnQsIHRoaXMpOworICAgIG1fd2ViRnJhbWUgPSBXZWJGcmFtZUltcGw6OmNyZWF0ZShkZWNvcmF0 ZWRDbGllbnQpOworICAgIG1fd2ViRnJhbWUtPmluaXRpYWxpemVBc01haW5GcmFtZShtX3BhZ2Uu Z2V0KCkpOworfQorCit2b2lkIFdlYkhlbHBlclBsdWdpbkltcGw6OnNldFBsdWdpbihXZWJQbHVn aW4qIHBsdWdpbikKK3sKKyAgICBBU1NFUlQoIW1fcGx1Z2luKTsKKyAgICBtX3BsdWdpbiA9IHBs dWdpbjsKIH0KIAogYm9vbCBXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0UGFnZShXZWJLaXQ6Oldl YlZpZXdJbXBsKiB3ZWJWaWV3LCBjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUpCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmggYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmgKaW5kZXggNmJkZDMz NTJmMTFmMjJkNWVkM2UxZDQ0NTFkYzA4YzM0MTk3NzY5ZS4uNDMyYzNhOTc0ZTE5MzM0M2JlYjY5 MWJlZDgyNmI4YWU4ZDRhMmY4ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViSGVscGVyUGx1Z2luSW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkhlbHBlclBsdWdpbkltcGwuaApAQCAtNDMsNiArNDMsOCBAQCBuYW1lc3BhY2UgV2ViS2l0 IHsKIAogY2xhc3MgSGVscGVyUGx1Z2luQ2hyb21lQ2xpZW50OwogY2xhc3MgV2ViRnJhbWVJbXBs OworY2xhc3MgSGVscGVyUGx1Z2luV2ViRnJhbWVDbGllbnQ7CitjbGFzcyBXZWJQbHVnaW47CiBj bGFzcyBXZWJWaWV3SW1wbDsKIGNsYXNzIFdlYldpZGdldENsaWVudDsKIApAQCAtNTUsNyArNTcs NyBAQCBjbGFzcyBXZWJIZWxwZXJQbHVnaW5JbXBsIDogcHVibGljIFdlYkhlbHBlclBsdWdpbiwK IAogcHVibGljOgogICAgIHZpcnR1YWwgfldlYkhlbHBlclBsdWdpbkltcGwoKTsKLSAgICBib29s IGluaXQoV2ViVmlld0ltcGwqLCBjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUpOworICAgIFdlYlBs dWdpbiogaW5pdChXZWJWaWV3SW1wbCosIGNvbnN0IFN0cmluZyYgcGx1Z2luVHlwZSk7CiAgICAg dm9pZCBjbG9zZUhlbHBlclBsdWdpbigpOwogCiAgICAgLy8gV2ViSGVscGVyUGx1Z2luIG1ldGhv ZHM6CkBAIC02NCw2ICs2Niw3IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgV2Vi SGVscGVyUGx1Z2luSW1wbChXZWJXaWRnZXRDbGllbnQqKTsKICAgICBib29sIGluaXRQYWdlKFdl YktpdDo6V2ViVmlld0ltcGwqLCBjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUpOworICAgIHZvaWQg c2V0UGx1Z2luKFdlYlBsdWdpbiopOwogCiAgICAgLy8gV2ViV2lkZ2V0IG1ldGhvZHM6CiAgICAg dmlydHVhbCB2b2lkIHNldENvbXBvc2l0b3JTdXJmYWNlUmVhZHkoKSBPVkVSUklERTsKQEAgLTc2 LDkgKzc5LDEyIEBAIHByaXZhdGU6CiAgICAgV2ViVmlld0ltcGwqIG1fd2ViVmlldzsKICAgICBP d25QdHI8V2ViQ29yZTo6UGFnZT4gbV9wYWdlOwogICAgIE93blB0cjxIZWxwZXJQbHVnaW5DaHJv bWVDbGllbnQ+IG1fY2hyb21lQ2xpZW50OworICAgIFJlZlB0cjxXZWJGcmFtZUltcGw+IG1fd2Vi RnJhbWU7CisgICAgV2ViUGx1Z2luKiBtX3BsdWdpbjsgLy8gT25seSB2YWxpZCBkdXJpbmcgaW5p dCgpLgogCiAgICAgZnJpZW5kIGNsYXNzIFdlYkhlbHBlclBsdWdpbjsKICAgICBmcmllbmQgY2xh c3MgSGVscGVyUGx1Z2luQ2hyb21lQ2xpZW50OworICAgIGZyaWVuZCBjbGFzcyBIZWxwZXJQbHVn aW5XZWJGcmFtZUNsaWVudDsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNw cCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5j cHAKaW5kZXggNjgwY2M5NTI4NzA0Zjc3MDkwNjRiZjIwNGRmYjdkZmYyZDA3YWQ0ZC4uODJhMTc0 MGNiZDZkNDQ3MmU0MGJjODdmMTMyMjY2Mjc3ZTNjM2NiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCkBAIC0y NjgsMTEgKzI2OCwxMyBAQCB2b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6a2V5TmVlZGVk KGNvbnN0IFdlYlN0cmluZyYga2V5U3lzdGVtLCBjb25zdCBXZWJTdAogI2VuZGlmCiB9CiAKLXZv aWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpjcmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgV2Vi U3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSogZnJhbWUpCitXZWJQbHVnaW4qIFdlYk1lZGlh UGxheWVyQ2xpZW50SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1 Z2luVHlwZSwgV2ViRnJhbWUqIGZyYW1lKQogewogICAgIEFTU0VSVCghbV9oZWxwZXJQbHVnaW4p OwogICAgIFdlYlZpZXdJbXBsKiB3ZWJWaWV3ID0gc3RhdGljX2Nhc3Q8V2ViVmlld0ltcGwqPihm cmFtZS0+dmlldygpKTsKLSAgICBtX2hlbHBlclBsdWdpbiA9IHdlYlZpZXctPmNyZWF0ZUhlbHBl clBsdWdpbihwbHVnaW5UeXBlKTsKKyAgICBXZWJQbHVnaW4qIHBsdWdpbiA9IDA7CisgICAgbV9o ZWxwZXJQbHVnaW4gPSB3ZWJWaWV3LT5jcmVhdGVIZWxwZXJQbHVnaW4ocGx1Z2luVHlwZSwgJnBs dWdpbik7CisgICAgcmV0dXJuIHBsdWdpbjsKIH0KIAogdm9pZCBXZWJNZWRpYVBsYXllckNsaWVu dEltcGw6OmNsb3NlSGVscGVyUGx1Z2luKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKaW5kZXggNjNhNDRkNzhiZjcxZGQw MjhhMTJkYzM2NDYwMzBiYjQ1MWQ1N2I5Mi4uNDFkNzYzNGM0OTNjMTc0YWExOTczOWNkNzZjNzVk ODExNGJkYjVjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVk aWFQbGF5ZXJDbGllbnRJbXBsLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi TWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgKQEAgLTkwLDcgKzkwLDcgQEAgcHVibGljOgogICAgIHZp cnR1YWwgdm9pZCBrZXlFcnJvcihjb25zdCBXZWJTdHJpbmcmIGtleVN5c3RlbSwgY29uc3QgV2Vi U3RyaW5nJiBzZXNzaW9uSWQsIE1lZGlhS2V5RXJyb3JDb2RlLCB1bnNpZ25lZCBzaG9ydCBzeXN0 ZW1Db2RlKTsKICAgICB2aXJ0dWFsIHZvaWQga2V5TWVzc2FnZShjb25zdCBXZWJTdHJpbmcmIGtl eVN5c3RlbSwgY29uc3QgV2ViU3RyaW5nJiBzZXNzaW9uSWQsIGNvbnN0IHVuc2lnbmVkIGNoYXIq IG1lc3NhZ2UsIHVuc2lnbmVkIG1lc3NhZ2VMZW5ndGgpOwogICAgIHZpcnR1YWwgdm9pZCBrZXlO ZWVkZWQoY29uc3QgV2ViU3RyaW5nJiBrZXlTeXN0ZW0sIGNvbnN0IFdlYlN0cmluZyYgc2Vzc2lv bklkLCBjb25zdCB1bnNpZ25lZCBjaGFyKiBpbml0RGF0YSwgdW5zaWduZWQgaW5pdERhdGFMZW5n dGgpOwotICAgIHZpcnR1YWwgdm9pZCBjcmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5n JiBwbHVnaW5UeXBlLCBXZWJGcmFtZSopOworICAgIHZpcnR1YWwgV2ViUGx1Z2luKiBjcmVhdGVI ZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSopOwogICAg IHZpcnR1YWwgdm9pZCBjbG9zZUhlbHBlclBsdWdpbigpOwogICAgIHZpcnR1YWwgdm9pZCBkaXNh YmxlQWNjZWxlcmF0ZWRDb21wb3NpdGluZygpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJWaWV3SW1wbC5jcHAKaW5kZXggM2U0ZTlmMDE2ZmQ2ZDczNzBhNmFkNThmYTM1NWUxYWE3 ZjQ4OTk3Yi4uN2Y4ZmQwZmY2ZDVhODY5OTFlN2VjNWYxYmM3MGZiMDBiNzM0MTFiOCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApAQCAtMTI3MSwxMyArMTI3 MSwxNSBAQCB2b2lkIFdlYlZpZXdJbXBsOjpoaWRlQXV0b2ZpbGxQb3B1cCgpCiAgICAgfQogfQog Ci1XZWJIZWxwZXJQbHVnaW5JbXBsKiBXZWJWaWV3SW1wbDo6Y3JlYXRlSGVscGVyUGx1Z2luKGNv bnN0IFN0cmluZyYgcGx1Z2luVHlwZSkKK1dlYkhlbHBlclBsdWdpbkltcGwqIFdlYlZpZXdJbXBs OjpjcmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJQbHVnaW4q KiBwbHVnaW4pCiB7CisgICAgQVNTRVJUKHBsdWdpbik7CiAgICAgV2ViV2lkZ2V0KiBwb3B1cFdp ZGdldCA9IG1fY2xpZW50LT5jcmVhdGVQb3B1cE1lbnUoV2ViUG9wdXBUeXBlSGVscGVyUGx1Z2lu KTsKICAgICBBU1NFUlQocG9wdXBXaWRnZXQpOwogICAgIFdlYkhlbHBlclBsdWdpbkltcGwqIGhl bHBlclBsdWdpbiA9IHN0YXRpY19jYXN0PFdlYkhlbHBlclBsdWdpbkltcGwqPihwb3B1cFdpZGdl dCk7CiAKLSAgICBpZiAoIWhlbHBlclBsdWdpbi0+aW5pdCh0aGlzLCBwbHVnaW5UeXBlKSkgewor ICAgICpwbHVnaW4gPSBoZWxwZXJQbHVnaW4tPmluaXQodGhpcywgcGx1Z2luVHlwZSk7CisgICAg aWYgKCEqcGx1Z2luKSB7CiAgICAgICAgIGhlbHBlclBsdWdpbi0+Y2xvc2VIZWxwZXJQbHVnaW4o KTsKICAgICAgICAgaGVscGVyUGx1Z2luID0gMDsKICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViVmlld0ltcGwuaAppbmRleCBhMDg4OTY3OGExNDAwNzQyY2MyNmUwZWJmYmJlMjNl MTk4YjkyZDJlLi43YTIzYmM2ZWVlOTdkNjU3YzZkMDFjYTM4OGE5ZDk4YWQ2Yzc3NTExIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKQEAgLTEwMyw2ICsxMDMsNyBA QCBjbGFzcyBXZWJEZXZUb29sc0FnZW50UHJpdmF0ZTsKIGNsYXNzIFdlYkZyYW1lSW1wbDsKIGNs YXNzIFdlYkdlc3R1cmVFdmVudDsKIGNsYXNzIFdlYlBhZ2VQb3B1cEltcGw7CitjbGFzcyBXZWJQ bHVnaW47CiBjbGFzcyBXZWJQcmVyZW5kZXJlckNsaWVudDsKIGNsYXNzIFdlYkltYWdlOwogY2xh c3MgV2ViS2V5Ym9hcmRFdmVudDsKQEAgLTQ5MCw3ICs0OTEsNyBAQCBwdWJsaWM6CiAKICAgICB2 b2lkIGhpZGVBdXRvZmlsbFBvcHVwKCk7CiAKLSAgICBXZWJIZWxwZXJQbHVnaW5JbXBsKiBjcmVh dGVIZWxwZXJQbHVnaW4oY29uc3QgU3RyaW5nJiBwbHVnaW5UeXBlKTsKKyAgICBXZWJIZWxwZXJQ bHVnaW5JbXBsKiBjcmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgU3RyaW5nJiBwbHVnaW5UeXBlLCBX ZWJQbHVnaW4qKik7CiAKICAgICAvLyBSZXR1cm5zIHRoZSBpbnB1dCBldmVudCB3ZSdyZSBjdXJy ZW50bHkgcHJvY2Vzc2luZy4gVGhpcyBpcyB1c2VkIGluIHNvbWUKICAgICAvLyBjYXNlcyB3aGVy ZSB0aGUgV2ViQ29yZSBET00gZXZlbnQgZG9lc24ndCBoYXZlIHRoZSBpbmZvcm1hdGlvbiB3ZSBu ZWVkLgo= 146173 2012-06-06 18:38:11 -0700 2012-06-07 18:26:40 -0700 Use getElementsByTagName() to get the WebPlugin bug-88028-20120606183811.patch text/plain 12711 ddorwin U3VidmVyc2lvbiBSZXZpc2lvbjogMTE5NTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGI2NjJkNzY1YzcxZTc4NDE4OThlYmI4ZmQxNWZiMGJhNmZiZjNkYTUuLmUzMjIxNTZhYzQ0NTQz YTIwNjJiYjNkYzIxODU3YTAyM2M4YzEzM2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMzggQEAKKzIwMTItMDYtMDYgIERhdmlkIERvcndpbiAgPGRkb3J3aW5AY2hyb21p dW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gUHJvdmlkZSBhY2Nlc3MgdG8gdGhlIFdlYlBs dWdpbiBjcmVhdGVkIGJ5IHRoZSBoZWxwZXIgcGx1Z2luIHdpZGdldAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODgwMjgKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBIFdlYlBsdWdpbiBpcyBjcmVhdGVkIHdo ZW4gdGhlIGRvY3VtZW50IGNyZWF0ZWQgYnkgY3JlYXRlSGVscGVyUGx1Z2luKCkgaXMgbGFpZCBv dXQuCisgICAgICAgIEV4cG9zZSBpdCBzbyB0aGUgZW1iZWRkZXIgY2FuIGludGVyYWN0IHdpdGgg dGhlIHBsdWdpbiBpbnN0YW5jZS4KKworICAgICAgICAqIHB1YmxpYy9XZWJIZWxwZXJQbHVnaW4u aDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJIZWxwZXJQbHVnaW4pOgorICAgICAg ICAqIHB1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0KToKKyAg ICAgICAgKiBwdWJsaWMvV2ViUGx1Z2luLmg6CisgICAgICAgIChXZWJLaXQ6OldlYlBsdWdpbjo6 aXNQbGFjZWhvbGRlcik6CisgICAgICAgIChXZWJLaXQ6OldlYlBsdWdpbjo6aXNQcGFwaSk6Cisg ICAgICAgIChXZWJQbHVnaW4pOgorICAgICAgICAqIHNyYy9XZWJGcmFtZUltcGwuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJGcmFtZUltcGw6On5XZWJGcmFtZUltcGwpOgorICAgICAgICAqIHNy Yy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViSGVscGVyUGx1 Z2luSW1wbDo6V2ViSGVscGVyUGx1Z2luSW1wbCk6CisgICAgICAgIChXZWJLaXQpOgorICAgICAg ICAoV2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjpnZXRQbHVnaW4pOgorICAgICAgICAoV2Vi S2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0UGFnZSk6CisgICAgICAgICogc3JjL1dlYkhl bHBlclBsdWdpbkltcGwuaDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJIZWxwZXJQ bHVnaW5JbXBsKToKKyAgICAgICAgKiBzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcDoK KyAgICAgICAgKFdlYktpdDo6V2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpjcmVhdGVIZWxwZXJQ bHVnaW4pOgorICAgICAgICAqIHNyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaDoKKyAgICAg ICAgKFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbCk6CisgICAgICAgICogc3JjL1dlYlBhZ2VQb3B1 cEltcGwuY3BwOgorCiAyMDEyLTA2LTA1ICBNYXJrIFBpbGdyaW0gIDxwaWxncmltQGNocm9taXVt Lm9yZz4KIAogICAgICAgICBbQ2hyb21pdW1dIE1vdmUgY3JlYXRlTG9jYWxTdG9yYWdlTmFtZXNw YWNlIHRvIFBsYXRmb3JtLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkhlbHBlclBsdWdpbi5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi SGVscGVyUGx1Z2luLmgKaW5kZXggYjZjYzE3ZDI2OGExOWU5ZTE3OTRkNDM2ZmIwNzI1NzZiOTg2 M2YwNS4uZDVjODc2ZjZlZTlhMTIzN2UwZGU4NTNiOTY4YmI1YzI5ZTBjMWEzNyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSGVscGVyUGx1Z2luLmgKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSGVscGVyUGx1Z2luLmgKQEAgLTM3LDYg KzM3LDcgQEAKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBXZWJGcmFtZUNsaWVudDsKK2Ns YXNzIFdlYlBsdWdpbjsKIGNsYXNzIFdlYldpZGdldENsaWVudDsKIAogY2xhc3MgV2ViSGVscGVy UGx1Z2luIDogcHVibGljIFdlYldpZGdldCB7CkBAIC00NCw2ICs0NSwxMCBAQCBwdWJsaWM6CiAg ICAgV0VCS0lUX0VYUE9SVCBzdGF0aWMgV2ViSGVscGVyUGx1Z2luKiBjcmVhdGUoV2ViV2lkZ2V0 Q2xpZW50Kik7CiAKICAgICB2aXJ0dWFsIHZvaWQgaW5pdGlhbGl6ZUZyYW1lKFdlYkZyYW1lQ2xp ZW50KikgPSAwOworICAgIC8vIFRoZSByZXR1cm5lZCBwb2ludGVyIG1heSBiZSAwIGV2ZW4gaWYg aW5pdGlhbGl6YXRpb24gd2FzIHN1Y2Nlc3NmdWwuCisgICAgLy8gRm9yIGV4YW1wbGUsIGlmIHRo ZSBwbHVnaW4gY2Fubm90IGJlIGZvdW5kIG9yIHRoZSBwbHVnaW4gaXMgZGlzYWJsZWQuCisgICAg Ly8gSWYgbm90IDAsIHRoZSByZXR1cm5lZCBwb2ludGVyIGlzIHZhbGlkIGZvciB0aGUgbGlmZXRp bWUgb2YgdGhpcyBvYmplY3QuCisgICAgdmlydHVhbCBXZWJQbHVnaW4qIGdldFBsdWdpbigpID0g MDsKIAogcHJvdGVjdGVkOgogICAgIH5XZWJIZWxwZXJQbHVnaW4oKSB7IH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50LmggYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oCmluZGV4 IGE0NmVlNWNlZDQ4YWM5ZjU4NWZjMWRkZDI0ZmEwMjIxODJiNGUxOTguLjFkOWM2NGRjODA2Mjc1 ZDM5YmRlNTk3Mjg3YThjYzAyZGY5ZDJjZjUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXJDbGllbnQuaApAQCAtMzYsNiArMzYsNyBAQAog bmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYkZyYW1lOworY2xhc3MgV2ViUGx1Z2luOwog Y2xhc3MgV2ViUmVxdWVzdDsKIGNsYXNzIFdlYlVSTDsKIApAQCAtNzYsNyArNzcsOSBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCB2b2lkIGtleUVycm9yKGNvbnN0IFdlYlN0cmluZyYsIGNvbnN0IFdl YlN0cmluZyYsIE1lZGlhS2V5RXJyb3JDb2RlLCB1bnNpZ25lZCBzaG9ydCBzeXN0ZW1Db2RlKSA9 IDA7CiAgICAgdmlydHVhbCB2b2lkIGtleU1lc3NhZ2UoY29uc3QgV2ViU3RyaW5nJiwgY29uc3Qg V2ViU3RyaW5nJiwgY29uc3QgdW5zaWduZWQgY2hhciosIHVuc2lnbmVkKSA9IDA7CiAgICAgdmly dHVhbCB2b2lkIGtleU5lZWRlZChjb25zdCBXZWJTdHJpbmcmLCBjb25zdCBXZWJTdHJpbmcmLCBj b25zdCB1bnNpZ25lZCBjaGFyKiBpbml0RGF0YSwgdW5zaWduZWQgaW5pdERhdGFMZW5ndGgpID0g MDsKLSAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYg cGx1Z2luVHlwZSwgV2ViRnJhbWUqKSA9IDA7CisgICAgLy8gVGhlIHJldHVybmVkIHBvaW50ZXIg aXMgdmFsaWQgdW50aWwgY2xvc2VIZWxwZXJQbHVnaW4oKSBpcyBjYWxsZWQuCisgICAgLy8gUmV0 dXJucyAwIGlmIHRoZSBwbHVnaW4gY291bGQgbm90IGJlIGluc3RhbnRpYXRlZC4KKyAgICB2aXJ0 dWFsIFdlYlBsdWdpbiogY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2lu VHlwZSwgV2ViRnJhbWUqKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGNsb3NlSGVscGVyUGx1Z2lu KCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBkaXNhYmxlQWNjZWxlcmF0ZWRDb21wb3NpdGluZygp ID0gMDsKIHByb3RlY3RlZDoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYlBsdWdpbi5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViUGx1Z2lu LmgKaW5kZXggNWI5MTFkMGI4ZmU3NmRiN2RkMDFmMTgyYzM1ZTg5Y2YzYTFiNjVkOS4uZWVkYTYy OWE1YjI5OWZhODZkMjQxZDM3NjRmODUxYWY1NzAxZDcxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViUGx1Z2luLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViUGx1Z2luLmgKQEAgLTEzOSw2ICsxMzksOSBAQCBwdWJsaWM6CiAgICAg Ly8gUm90YXRlcyB0aGUgcGx1Z2luJ3MgdmlldyBvZiBpdHMgY29udGVudC4KICAgICB2aXJ0dWFs IHZvaWQgcm90YXRlVmlldyhSb3RhdGlvblR5cGUgdHlwZSkgeyB9CiAKKyAgICB2aXJ0dWFsIGJv b2wgaXNQbGFjZWhvbGRlcigpIHsgcmV0dXJuIHRydWU7IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNQ cGFwaSgpIHsgcmV0dXJuIGZhbHNlOyB9CisKIHByb3RlY3RlZDoKICAgICB+V2ViUGx1Z2luKCkg eyB9CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViRnJhbWVJ bXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkZyYW1lSW1wbC5jcHAKaW5k ZXggZjc2ZGRkNmI3MThjN2ZmODQ1YjdjMjM1MDRmN2EwOTM1OTJlZjUzNS4uMmI1NzNmZGI4ZDM3 NWE3YjJlNTI1YzhkNGNkZDZmMGNkYTk2MWY3ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViRnJhbWVJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJGcmFtZUltcGwuY3BwCkBAIC0yMDU3LDYgKzIwNTcsMTAgQEAgV2ViRnJhbWVJbXBs OjpXZWJGcmFtZUltcGwoV2ViRnJhbWVDbGllbnQqIGNsaWVudCkKIAogV2ViRnJhbWVJbXBsOjp+ V2ViRnJhbWVJbXBsKCkKIHsKKyAgICAvLyBUZWxsIHRoZSBjbGllbnQgdGhhdCB0aGlzIG9iamVj dCBpcyBubyBsb25nZXIgdmFsaWQuCisgICAgaWYgKGNsaWVudCgpKQorICAgICAgICBjbGllbnQo KS0+ZnJhbWVEZXRhY2hlZCh0aGlzKTsKKwogICAgIFdlYktpdDo6UGxhdGZvcm06OmN1cnJlbnQo KS0+ZGVjcmVtZW50U3RhdHNDb3VudGVyKHdlYkZyYW1lQWN0aXZlQ291bnQpOwogICAgIGZyYW1l Q291bnQtLTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVs cGVyUGx1Z2luSW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQ bHVnaW5JbXBsLmNwcAppbmRleCAxNTgxZGVhMjg4Yzc5NDk2ZTJkNzE3N2YyYmE4NTZmMmM2YjYz NzE3Li5iZjFiYjBiYmNmN2Y0NDk2NWZlYTZiMmQ2YWM2ZTc1NDIyNTQxZGM3IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcApAQCAt MzEsMTUgKzMxLDE4IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV2ViSGVscGVy UGx1Z2luSW1wbC5oIgogCi0jaW5jbHVkZSAiQ2hyb21lLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnRM b2FkZXIuaCIKICNpbmNsdWRlICJFbXB0eUNsaWVudHMuaCIKICNpbmNsdWRlICJGb2N1c0NvbnRy b2xsZXIuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKKyNpbmNsdWRlICJIVE1MUGx1Z0luRWxl bWVudC5oIgorI2luY2x1ZGUgIk5vZGVMaXN0LmgiCiAjaW5jbHVkZSAiUGFnZS5oIgogI2luY2x1 ZGUgIlBhZ2VXaWRnZXREZWxlZ2F0ZS5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVk ZSAiV2ViRnJhbWVJbXBsLmgiCisjaW5jbHVkZSAiV2ViUGx1Z2luLmgiCisjaW5jbHVkZSAiV2Vi UGx1Z2luQ29udGFpbmVySW1wbC5oIgogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKICNpbmNs dWRlICJXZWJWaWV3SW1wbC5oIgogI2luY2x1ZGUgIldlYldpZGdldENsaWVudC5oIgpAQCAtOTks NiArMTAyLDcgQEAgcHJpdmF0ZToKIAogV2ViSGVscGVyUGx1Z2luSW1wbDo6V2ViSGVscGVyUGx1 Z2luSW1wbChXZWJXaWRnZXRDbGllbnQqIGNsaWVudCkKICAgICA6IG1fd2lkZ2V0Q2xpZW50KGNs aWVudCkKKyAgICAsIG1fd2ViVmlldygwKQogewogICAgIEFTU0VSVChjbGllbnQpOwogfQpAQCAt MTQzLDYgKzE0NywyOCBAQCB2b2lkIFdlYkhlbHBlclBsdWdpbkltcGw6OmluaXRpYWxpemVGcmFt ZShXZWJGcmFtZUNsaWVudCogY2xpZW50KQogICAgIGZyYW1lLT5pbml0aWFsaXplQXNNYWluRnJh bWUobV9wYWdlLmdldCgpKTsKIH0KIAorLy8gUmV0dXJucyBhIHBvaW50ZXIgdG8gdGhlIFdlYlBs dWdpbiBieSBmaW5kaW5nIHRoZSBzaW5nbGUgPG9iamVjdD4gdGFnIGluIHRoZSBwYWdlLgorV2Vi UGx1Z2luKiBXZWJIZWxwZXJQbHVnaW5JbXBsOjpnZXRQbHVnaW4oKQoreworICAgIEFTU0VSVCht X3BhZ2UpOworCisgICAgUmVmUHRyPE5vZGVMaXN0PiBvYmplY3RFbGVtZW50cyA9IG1fcGFnZS0+ bWFpbkZyYW1lKCktPmRvY3VtZW50KCktPmdldEVsZW1lbnRzQnlUYWdOYW1lKCJvYmplY3QiKTsK KyAgICBBU1NFUlQob2JqZWN0RWxlbWVudHMtPmxlbmd0aCgpID09IDEpOworICAgIE5vZGUqIG5v ZGUgPSBvYmplY3RFbGVtZW50cy0+aXRlbSgwKTsKKyAgICBXZWJDb3JlOjpXaWRnZXQqIHdpZGdl dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8SFRNTFBsdWdJbkVsZW1lbnQqPihub2RlKS0+cGx1Z2luV2lk Z2V0KCk7CisgICAgaWYgKCF3aWRnZXQpCisgICAgICAgIHJldHVybiAwOworICAgIFdlYlBsdWdp biogcGx1Z2luID0gcmVpbnRlcnByZXRfY2FzdDxXZWJQbHVnaW5Db250YWluZXJJbXBsKj4od2lk Z2V0KS0+cGx1Z2luKCk7CisgICAgQVNTRVJUKHBsdWdpbik7CisgICAgLy8gSWYgdGhlIHBsdWdp biBpcyBhIHBsYWNlaG9sZGVyLCBpdCBpcyBub3QgdXNlZnVsIHRvIHRoZSBjYWxsZXIsIGFuZCBp dAorICAgIC8vIGNvdWxkIGJlIHJlcGxhY2VkIGF0IGFueSB0aW1lLiBUaGVyZWZvcmUsIGRvIG5v dCByZXR1cm4gaXQuCisgICAgaWYgKHBsdWdpbi0+aXNQbGFjZWhvbGRlcigpKQorICAgICAgICBy ZXR1cm4gMDsKKworICAgIC8vIFRoZSBwbHVnaW4gd2FzIGluc3RhbnRpYXRlZCBhbmQgd2lsbCBv dXRsaXZlIHRoaXMgb2JqZWN0LgorICAgIHJldHVybiBwbHVnaW47Cit9CisKIGJvb2wgV2ViSGVs cGVyUGx1Z2luSW1wbDo6aW5pdFBhZ2UoV2ViS2l0OjpXZWJWaWV3SW1wbCogd2ViVmlldywgY29u c3QgU3RyaW5nJiBwbHVnaW5UeXBlKQogewogICAgIFBhZ2U6OlBhZ2VDbGllbnRzIHBhZ2VDbGll bnRzOwpAQCAtMTU3LDcgKzE4Myw3IEBAIGJvb2wgV2ViSGVscGVyUGx1Z2luSW1wbDo6aW5pdFBh Z2UoV2ViS2l0OjpXZWJWaWV3SW1wbCogd2ViVmlldywgY29uc3QgU3RyaW5nJiBwCiAKICAgICB3 ZWJWaWV3LT5jbGllbnQoKS0+aW5pdGlhbGl6ZUhlbHBlclBsdWdpbldlYkZyYW1lKHRoaXMpOwog Ci0gICAgLy8gVGhlIHBhZ2UncyBtYWluIGZyYW1lIHdhcyBzZXQgaW4gaW5pdGlhbGl6ZU1haW5G cmFtZSgpIGFzIGEgcmVzdWx0IG9mIHRoZSBhYm92ZSBjYWxsLgorICAgIC8vIFRoZSBwYWdlJ3Mg bWFpbiBmcmFtZSB3YXMgc2V0IGluIGluaXRpYWxpemVGcmFtZSgpIGFzIGEgcmVzdWx0IG9mIHRo ZSBhYm92ZSBjYWxsLgogICAgIEZyYW1lKiBmcmFtZSA9IG1fcGFnZS0+bWFpbkZyYW1lKCk7CiAg ICAgQVNTRVJUKGZyYW1lKTsKICAgICBmcmFtZS0+c2V0VmlldyhGcmFtZVZpZXc6OmNyZWF0ZShm cmFtZSkpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVy UGx1Z2luSW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2lu SW1wbC5oCmluZGV4IDZiZGQzMzUyZjExZjIyZDVlZDNlMWQ0NDUxZGMwOGMzNDE5Nzc2OWUuLjJl YjI4ZWMzMTBlNTY1MTFkMGUzZjg0MjY4YmU3MDZmYWUzMGQ3MzkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhlbHBlclBsdWdpbkltcGwuaAorKysgYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmgKQEAgLTQyLDcgKzQyLDYg QEAgY2xhc3MgUGFnZTsKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBIZWxwZXJQbHVnaW5D aHJvbWVDbGllbnQ7Ci1jbGFzcyBXZWJGcmFtZUltcGw7CiBjbGFzcyBXZWJWaWV3SW1wbDsKIGNs YXNzIFdlYldpZGdldENsaWVudDsKIApAQCAtNjAsNiArNTksNyBAQCBwdWJsaWM6CiAKICAgICAv LyBXZWJIZWxwZXJQbHVnaW4gbWV0aG9kczoKICAgICB2aXJ0dWFsIHZvaWQgaW5pdGlhbGl6ZUZy YW1lKFdlYkZyYW1lQ2xpZW50KikgT1ZFUlJJREU7CisgICAgdmlydHVhbCBXZWJQbHVnaW4qIGdl dFBsdWdpbigpIE9WRVJSSURFOwogCiBwcml2YXRlOgogICAgIGV4cGxpY2l0IFdlYkhlbHBlclBs dWdpbkltcGwoV2ViV2lkZ2V0Q2xpZW50Kik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcAppbmRleCA0MGJlNGQ2ZDM0 N2YzN2E5N2ZiYjc2YjQ5YTdmNGMwZjUwMzdlNjg4Li5mMGRjYWNiMGEzZDdjZGFmOTY2Y2NmZTFh Mjc0OTk1MmRlMzJkNzNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKQEAgLTI2OCwxMSArMjY4LDIzIEBAIHZv aWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjprZXlOZWVkZWQoY29uc3QgV2ViU3RyaW5nJiBr ZXlTeXN0ZW0sIGNvbnN0IFdlYlN0CiAjZW5kaWYKIH0KIAotdm9pZCBXZWJNZWRpYVBsYXllckNs aWVudEltcGw6OmNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUs IFdlYkZyYW1lKiBmcmFtZSkKK1dlYlBsdWdpbiogV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpj cmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSog ZnJhbWUpCiB7CiAgICAgQVNTRVJUKCFtX2hlbHBlclBsdWdpbik7CiAgICAgV2ViVmlld0ltcGwq IHdlYlZpZXcgPSBzdGF0aWNfY2FzdDxXZWJWaWV3SW1wbCo+KGZyYW1lLT52aWV3KCkpOwogICAg IG1faGVscGVyUGx1Z2luID0gd2ViVmlldy0+Y3JlYXRlSGVscGVyUGx1Z2luKHBsdWdpblR5cGUp OworICAgIGlmICghbV9oZWxwZXJQbHVnaW4pCisgICAgICAgIHJldHVybiAwOworCisgICAgV2Vi UGx1Z2luKiBwbHVnaW4gPSBtX2hlbHBlclBsdWdpbi0+Z2V0UGx1Z2luKCk7CisgICAgaWYgKCFw bHVnaW4pIHsKKyAgICAgICAgLy8gVGhlcmUgaXMgbm8gbmVlZCB0byBrZWVwIHRoZSBoZWxwZXIg cGx1Z2luIGFyb3VuZCBhbmQgdGhlIGNhbGxlcgorICAgICAgICAvLyBzaG91bGQgbm90IGJlIGV4 cGVjdGVkIHRvIGNhbGwgY2xvc2UgYWZ0ZXIgYSBmYWlsdXJlIChudWxsIHBvaW50ZXIpLgorICAg ICAgICBjbG9zZUhlbHBlclBsdWdpbigpOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAg ICByZXR1cm4gcGx1Z2luOwogfQogCiB2b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6Y2xv c2VIZWxwZXJQbHVnaW4oKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJNZWRpYVBsYXllckNsaWVudEltcGwuaAppbmRleCA5MDJkZGM4MzQ3YjFhYzUwYTVhNmQwY2M2 NjUwYjczMjcwMWQ4M2YyLi5jMTk3ZmZkOTk3YzEwYTFhMWMyYzNmOWU1NmZmZGI4YTkyM2FjMTMw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNs aWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXll ckNsaWVudEltcGwuaApAQCAtOTAsNyArOTAsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lk IGtleUVycm9yKGNvbnN0IFdlYlN0cmluZyYga2V5U3lzdGVtLCBjb25zdCBXZWJTdHJpbmcmIHNl c3Npb25JZCwgTWVkaWFLZXlFcnJvckNvZGUsIHVuc2lnbmVkIHNob3J0IHN5c3RlbUNvZGUpOwog ICAgIHZpcnR1YWwgdm9pZCBrZXlNZXNzYWdlKGNvbnN0IFdlYlN0cmluZyYga2V5U3lzdGVtLCBj b25zdCBXZWJTdHJpbmcmIHNlc3Npb25JZCwgY29uc3QgdW5zaWduZWQgY2hhciogbWVzc2FnZSwg dW5zaWduZWQgbWVzc2FnZUxlbmd0aCk7CiAgICAgdmlydHVhbCB2b2lkIGtleU5lZWRlZChjb25z dCBXZWJTdHJpbmcmIGtleVN5c3RlbSwgY29uc3QgV2ViU3RyaW5nJiBzZXNzaW9uSWQsIGNvbnN0 IHVuc2lnbmVkIGNoYXIqIGluaXREYXRhLCB1bnNpZ25lZCBpbml0RGF0YUxlbmd0aCk7Ci0gICAg dmlydHVhbCB2b2lkIGNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5 cGUsIFdlYkZyYW1lKik7CisgICAgdmlydHVhbCBXZWJQbHVnaW4qIGNyZWF0ZUhlbHBlclBsdWdp bihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKik7CiAgICAgdmlydHVhbCB2 b2lkIGNsb3NlSGVscGVyUGx1Z2luKCk7CiAgICAgdmlydHVhbCB2b2lkIGRpc2FibGVBY2NlbGVy YXRlZENvbXBvc2l0aW5nKCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlBhZ2VQb3B1cEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi UGFnZVBvcHVwSW1wbC5jcHAKaW5kZXggYWU1YWFjOGE0MDczZmI1ODcxZDk3MzRkN2Y0NDc3Y2Fi ZmNlYzM2ZC4uMGU1MGFmZTI0YWUxZGE3MzMwYzdmYjU5ODAwMThiN2VjY2U1YjQyYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViUGFnZVBvcHVwSW1wbC5jcHAKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViUGFnZVBvcHVwSW1wbC5jcHAKQEAgLTM2 LDEzICszNiwxMSBAQAogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgiCiAjaW5jbHVkZSAiRW1w dHlDbGllbnRzLmgiCiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCi0jaW5jbHVkZSAiRnJh bWUuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJQYWdlLmgiCiAjaW5jbHVk ZSAiUGFnZVBvcHVwQ2xpZW50LmgiCiAjaW5jbHVkZSAiUGFnZVdpZGdldERlbGVnYXRlLmgiCiAj aW5jbHVkZSAiU2V0dGluZ3MuaCIKLSNpbmNsdWRlICJXZWJJbnB1dEV2ZW50LmgiCiAjaW5jbHVk ZSAiV2ViSW5wdXRFdmVudENvbnZlcnNpb24uaCIKICNpbmNsdWRlICJXZWJQYWdlUG9wdXAuaCIK ICNpbmNsdWRlICJXZWJWaWV3SW1wbC5oIgpkaWZmIC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIv VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDU0Mjg4MGU3ZDc4OGJiNWMzYTY4ZGJhM2YwMzJlNzYyYjk4 YTZhMDIuLmM0YTU0NjA5OWYzMmE1NzEyYWE1ZmI4YTMwOThjMTFkNjk0NjFmZTIgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBA QAorMjAxMi0wNi0wNiAgRGF2aWQgRG9yd2luICA8ZGRvcndpbkBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgW2Nocm9taXVtXSBQcm92aWRlIGFjY2VzcyB0byB0aGUgV2ViUGx1Z2luIGNyZWF0ZWQg YnkgdGhlIGhlbHBlciBwbHVnaW4gd2lkZ2V0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD04ODAyOAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZGVkIGlzUGxhY2Vob2xkZXIoKSB0byBXZWJQbHVnaW4uCisK KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0V2ViUGx1Z2luLmg6CisgICAg ICAgIChUZXN0V2ViUGx1Z2luOjppc1BsYWNlaG9sZGVyKToKKwogMjAxMi0wNi0wNSAgSm9uIExl ZSAgPGpvbmxlZUBhcHBsZS5jb20+CiAKICAgICAgICAgQnVpbGRib3QgZml4LgpkaWZmIC0tZ2l0 IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYlBsdWdpbi5oIGIvVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYlBsdWdpbi5oCmluZGV4IDg1ODEyODhhY2I2 OGIwZDA3OTM4Y2VjZDlhZjVlMzc1MzZmNmJiMTkuLjRjOWYyZjRkMjI4NTc5Y2NmNmExNjQ1NmJm MGFkMzQ0Y2FkODlmNzAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVt L1Rlc3RXZWJQbHVnaW4uaAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0 V2ViUGx1Z2luLmgKQEAgLTY4LDYgKzY4LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBk aWRGYWlsTG9hZGluZyhjb25zdCBXZWJLaXQ6OldlYlVSTEVycm9yJikgeyB9CiAgICAgdmlydHVh bCB2b2lkIGRpZEZpbmlzaExvYWRpbmdGcmFtZVJlcXVlc3QoY29uc3QgV2ViS2l0OjpXZWJVUkwm LCB2b2lkKiBub3RpZnlEYXRhKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlkRmFpbExvYWRpbmdG cmFtZVJlcXVlc3QoY29uc3QgV2ViS2l0OjpXZWJVUkwmLCB2b2lkKiBub3RpZnlEYXRhLCBjb25z dCBXZWJLaXQ6OldlYlVSTEVycm9yJikgeyB9CisgICAgdmlydHVhbCBib29sIGlzUGxhY2Vob2xk ZXIoKSB7IHJldHVybiBmYWxzZTsgfQogCiBwcml2YXRlOgogICAgIGVudW0gUHJpbWl0aXZlIHsK 146417 2012-06-07 16:51:19 -0700 2012-06-07 18:31:57 -0700 Review feedback bug-88028-20120607165118.patch text/plain 12743 ddorwin U3VidmVyc2lvbiBSZXZpc2lvbjogMTE5NTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGI2NjJkNzY1YzcxZTc4NDE4OThlYmI4ZmQxNWZiMGJhNmZiZjNkYTUuLjFmMDVhMDVmMDQ5Mzhj Yjg2MWM5NmU1ZWFlMTcxZjE3N2UxNmEyYTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMzcgQEAKKzIwMTItMDYtMDYgIERhdmlkIERvcndpbiAgPGRkb3J3aW5AY2hyb21p dW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gUHJvdmlkZSBhY2Nlc3MgdG8gdGhlIFdlYlBs dWdpbiBjcmVhdGVkIGJ5IHRoZSBoZWxwZXIgcGx1Z2luIHdpZGdldAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODgwMjgKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBIFdlYlBsdWdpbiBpcyBjcmVhdGVkIHdo ZW4gdGhlIGRvY3VtZW50IGNyZWF0ZWQgYnkgY3JlYXRlSGVscGVyUGx1Z2luKCkgaXMgbGFpZCBv dXQuCisgICAgICAgIEV4cG9zZSBpdCBzbyB0aGUgZW1iZWRkZXIgY2FuIGludGVyYWN0IHdpdGgg dGhlIHBsdWdpbiBpbnN0YW5jZS4KKworICAgICAgICAqIHB1YmxpYy9XZWJIZWxwZXJQbHVnaW4u aDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJIZWxwZXJQbHVnaW4pOgorICAgICAg ICAqIHB1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0KToKKyAg ICAgICAgKiBwdWJsaWMvV2ViUGx1Z2luLmg6CisgICAgICAgIChXZWJLaXQ6OldlYlBsdWdpbjo6 aXNQbGFjZWhvbGRlcik6CisgICAgICAgIChXZWJQbHVnaW4pOgorICAgICAgICAqIHNyYy9XZWJG cmFtZUltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJGcmFtZUltcGw6On5XZWJGcmFtZUlt cGwpOgorICAgICAgICAqIHNyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcDoKKyAgICAgICAgKFdl YktpdDo6V2ViSGVscGVyUGx1Z2luSW1wbDo6V2ViSGVscGVyUGx1Z2luSW1wbCk6CisgICAgICAg IChXZWJLaXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjpnZXRQbHVn aW4pOgorICAgICAgICAoV2ViS2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0UGFnZSk6Cisg ICAgICAgICogc3JjL1dlYkhlbHBlclBsdWdpbkltcGwuaDoKKyAgICAgICAgKFdlYktpdCk6Cisg ICAgICAgIChXZWJIZWxwZXJQbHVnaW5JbXBsKToKKyAgICAgICAgKiBzcmMvV2ViTWVkaWFQbGF5 ZXJDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTWVkaWFQbGF5ZXJDbGllbnRJ bXBsOjpjcmVhdGVIZWxwZXJQbHVnaW4pOgorICAgICAgICAqIHNyYy9XZWJNZWRpYVBsYXllckNs aWVudEltcGwuaDoKKyAgICAgICAgKFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbCk6CisgICAgICAg ICogc3JjL1dlYlBhZ2VQb3B1cEltcGwuY3BwOgorCiAyMDEyLTA2LTA1ICBNYXJrIFBpbGdyaW0g IDxwaWxncmltQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbQ2hyb21pdW1dIE1vdmUgY3JlYXRl TG9jYWxTdG9yYWdlTmFtZXNwYWNlIHRvIFBsYXRmb3JtLmgKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkhlbHBlclBsdWdpbi5oIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViSGVscGVyUGx1Z2luLmgKaW5kZXggYjZjYzE3ZDI2OGExOWU5ZTE3 OTRkNDM2ZmIwNzI1NzZiOTg2M2YwNS4uM2NlMWE1YmE4YzAxZGEzMzc2MjRjMmY3YTJiMTFlNjY3 ZjM3NmFlOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSGVs cGVyUGx1Z2luLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSGVscGVy UGx1Z2luLmgKQEAgLTM3LDYgKzM3LDcgQEAKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFzcyBX ZWJGcmFtZUNsaWVudDsKK2NsYXNzIFdlYlBsdWdpbjsKIGNsYXNzIFdlYldpZGdldENsaWVudDsK IAogY2xhc3MgV2ViSGVscGVyUGx1Z2luIDogcHVibGljIFdlYldpZGdldCB7CkBAIC00NSw2ICs0 NiwxMSBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgaW5pdGlhbGl6ZUZyYW1lKFdlYkZy YW1lQ2xpZW50KikgPSAwOwogCisgICAgLy8gVGhlIHJldHVybmVkIHBvaW50ZXIgbWF5IGJlIDAg ZXZlbiBpZiBpbml0aWFsaXphdGlvbiB3YXMgc3VjY2Vzc2Z1bC4KKyAgICAvLyBGb3IgZXhhbXBs ZSwgaWYgdGhlIHBsdWdpbiBjYW5ub3QgYmUgZm91bmQgb3IgdGhlIHBsdWdpbiBpcyBkaXNhYmxl ZC4KKyAgICAvLyBJZiBub3QgMCwgdGhlIHJldHVybmVkIHBvaW50ZXIgaXMgdmFsaWQgZm9yIHRo ZSBsaWZldGltZSBvZiB0aGlzIG9iamVjdC4KKyAgICB2aXJ0dWFsIFdlYlBsdWdpbiogZ2V0UGx1 Z2luKCkgPSAwOworCiBwcm90ZWN0ZWQ6CiAgICAgfldlYkhlbHBlclBsdWdpbigpIHsgfQogfTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVy Q2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRpYVBsYXllckNs aWVudC5oCmluZGV4IGE0NmVlNWNlZDQ4YWM5ZjU4NWZjMWRkZDI0ZmEwMjIxODJiNGUxOTguLjFk OWM2NGRjODA2Mjc1ZDM5YmRlNTk3Mjg3YThjYzAyZGY5ZDJjZjUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50LmgKKysrIGIvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXJDbGllbnQuaApAQCAtMzYs NiArMzYsNyBAQAogbmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYkZyYW1lOworY2xhc3Mg V2ViUGx1Z2luOwogY2xhc3MgV2ViUmVxdWVzdDsKIGNsYXNzIFdlYlVSTDsKIApAQCAtNzYsNyAr NzcsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGtleUVycm9yKGNvbnN0IFdlYlN0cmlu ZyYsIGNvbnN0IFdlYlN0cmluZyYsIE1lZGlhS2V5RXJyb3JDb2RlLCB1bnNpZ25lZCBzaG9ydCBz eXN0ZW1Db2RlKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGtleU1lc3NhZ2UoY29uc3QgV2ViU3Ry aW5nJiwgY29uc3QgV2ViU3RyaW5nJiwgY29uc3QgdW5zaWduZWQgY2hhciosIHVuc2lnbmVkKSA9 IDA7CiAgICAgdmlydHVhbCB2b2lkIGtleU5lZWRlZChjb25zdCBXZWJTdHJpbmcmLCBjb25zdCBX ZWJTdHJpbmcmLCBjb25zdCB1bnNpZ25lZCBjaGFyKiBpbml0RGF0YSwgdW5zaWduZWQgaW5pdERh dGFMZW5ndGgpID0gMDsKLSAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0 IFdlYlN0cmluZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUqKSA9IDA7CisgICAgLy8gVGhlIHJldHVy bmVkIHBvaW50ZXIgaXMgdmFsaWQgdW50aWwgY2xvc2VIZWxwZXJQbHVnaW4oKSBpcyBjYWxsZWQu CisgICAgLy8gUmV0dXJucyAwIGlmIHRoZSBwbHVnaW4gY291bGQgbm90IGJlIGluc3RhbnRpYXRl ZC4KKyAgICB2aXJ0dWFsIFdlYlBsdWdpbiogY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0 cmluZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUqKSA9IDA7CiAgICAgdmlydHVhbCB2b2lkIGNsb3Nl SGVscGVyUGx1Z2luKCkgPSAwOwogICAgIHZpcnR1YWwgdm9pZCBkaXNhYmxlQWNjZWxlcmF0ZWRD b21wb3NpdGluZygpID0gMDsKIHByb3RlY3RlZDoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYlBsdWdpbi5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViUGx1Z2luLmgKaW5kZXggNWI5MTFkMGI4ZmU3NmRiN2RkMDFmMTgyYzM1ZTg5Y2YzYTFi NjVkOS4uNWVmODg0YzczYTNiZThkYWI5YTFmY2VjZWU4YjU4Y2QxOGNiZmMwYiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViUGx1Z2luLmgKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViUGx1Z2luLmgKQEAgLTEzOSw2ICsxMzksOCBAQCBw dWJsaWM6CiAgICAgLy8gUm90YXRlcyB0aGUgcGx1Z2luJ3MgdmlldyBvZiBpdHMgY29udGVudC4K ICAgICB2aXJ0dWFsIHZvaWQgcm90YXRlVmlldyhSb3RhdGlvblR5cGUgdHlwZSkgeyB9CiAKKyAg ICB2aXJ0dWFsIGJvb2wgaXNQbGFjZWhvbGRlcigpIHsgcmV0dXJuIHRydWU7IH0KKwogcHJvdGVj dGVkOgogICAgIH5XZWJQbHVnaW4oKSB7IH0KIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJGcmFtZUltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViRnJhbWVJbXBsLmNwcAppbmRleCBmNzZkZGQ2YjcxOGM3ZmY4NDViN2MyMzUwNGY3YTA5 MzU5MmVmNTM1Li4yYjU3M2ZkYjhkMzc1YTdiMmU1MjVjOGQ0Y2RkNmYwY2RhOTYxZjdlIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJGcmFtZUltcGwuY3BwCisrKyBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkZyYW1lSW1wbC5jcHAKQEAgLTIwNTcsNiAr MjA1NywxMCBAQCBXZWJGcmFtZUltcGw6OldlYkZyYW1lSW1wbChXZWJGcmFtZUNsaWVudCogY2xp ZW50KQogCiBXZWJGcmFtZUltcGw6On5XZWJGcmFtZUltcGwoKQogeworICAgIC8vIFRlbGwgdGhl IGNsaWVudCB0aGF0IHRoaXMgb2JqZWN0IGlzIG5vIGxvbmdlciB2YWxpZC4KKyAgICBpZiAoY2xp ZW50KCkpCisgICAgICAgIGNsaWVudCgpLT5mcmFtZURldGFjaGVkKHRoaXMpOworCiAgICAgV2Vi S2l0OjpQbGF0Zm9ybTo6Y3VycmVudCgpLT5kZWNyZW1lbnRTdGF0c0NvdW50ZXIod2ViRnJhbWVB Y3RpdmVDb3VudCk7CiAgICAgZnJhbWVDb3VudC0tOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkhlbHBlclBsdWdpbkltcGwuY3BwCmluZGV4IDE1ODFkZWEyODhjNzk0 OTZlMmQ3MTc3ZjJiYTg1NmYyYzZiNjM3MTcuLjgzM2I3NGViMzdhYjU4NmIwYjZmYjA3YjBjOGI0 ZjUwZDIwNDA4MGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhl bHBlclBsdWdpbkltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhl bHBlclBsdWdpbkltcGwuY3BwCkBAIC0zMSwxNSArMzEsMTggQEAKICNpbmNsdWRlICJjb25maWcu aCIKICNpbmNsdWRlICJXZWJIZWxwZXJQbHVnaW5JbXBsLmgiCiAKLSNpbmNsdWRlICJDaHJvbWUu aCIKICNpbmNsdWRlICJEb2N1bWVudExvYWRlci5oIgogI2luY2x1ZGUgIkVtcHR5Q2xpZW50cy5o IgogI2luY2x1ZGUgIkZvY3VzQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgor I2luY2x1ZGUgIkhUTUxQbHVnSW5FbGVtZW50LmgiCisjaW5jbHVkZSAiTm9kZUxpc3QuaCIKICNp bmNsdWRlICJQYWdlLmgiCiAjaW5jbHVkZSAiUGFnZVdpZGdldERlbGVnYXRlLmgiCiAjaW5jbHVk ZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKKyNpbmNsdWRlICJXZWJQ bHVnaW4uaCIKKyNpbmNsdWRlICJXZWJQbHVnaW5Db250YWluZXJJbXBsLmgiCiAjaW5jbHVkZSAi V2ViVmlld0NsaWVudC5oIgogI2luY2x1ZGUgIldlYlZpZXdJbXBsLmgiCiAjaW5jbHVkZSAiV2Vi V2lkZ2V0Q2xpZW50LmgiCkBAIC05OSw2ICsxMDIsNyBAQCBwcml2YXRlOgogCiBXZWJIZWxwZXJQ bHVnaW5JbXBsOjpXZWJIZWxwZXJQbHVnaW5JbXBsKFdlYldpZGdldENsaWVudCogY2xpZW50KQog ICAgIDogbV93aWRnZXRDbGllbnQoY2xpZW50KQorICAgICwgbV93ZWJWaWV3KDApCiB7CiAgICAg QVNTRVJUKGNsaWVudCk7CiB9CkBAIC0xNDMsNiArMTQ3LDMxIEBAIHZvaWQgV2ViSGVscGVyUGx1 Z2luSW1wbDo6aW5pdGlhbGl6ZUZyYW1lKFdlYkZyYW1lQ2xpZW50KiBjbGllbnQpCiAgICAgZnJh bWUtPmluaXRpYWxpemVBc01haW5GcmFtZShtX3BhZ2UuZ2V0KCkpOwogfQogCisvLyBSZXR1cm5z IGEgcG9pbnRlciB0byB0aGUgV2ViUGx1Z2luIGJ5IGZpbmRpbmcgdGhlIHNpbmdsZSA8b2JqZWN0 PiB0YWcgaW4gdGhlIHBhZ2UuCitXZWJQbHVnaW4qIFdlYkhlbHBlclBsdWdpbkltcGw6OmdldFBs dWdpbigpCit7CisgICAgQVNTRVJUKG1fcGFnZSk7CisKKyAgICBSZWZQdHI8Tm9kZUxpc3Q+IG9i amVjdEVsZW1lbnRzID0gbV9wYWdlLT5tYWluRnJhbWUoKS0+ZG9jdW1lbnQoKS0+Z2V0RWxlbWVu dHNCeVRhZ05hbWUoV2ViQ29yZTo6SFRNTE5hbWVzOjpvYmplY3RUYWcubG9jYWxOYW1lKCkpOwor ICAgIEFTU0VSVChvYmplY3RFbGVtZW50cyAmJiBvYmplY3RFbGVtZW50cy0+bGVuZ3RoKCkgPT0g MSk7CisgICAgaWYgKCFvYmplY3RFbGVtZW50cyB8fCBvYmplY3RFbGVtZW50cy0+bGVuZ3RoKCkg PCAxKQorICAgICAgICByZXR1cm4gMDsKKyAgICBOb2RlKiBub2RlID0gb2JqZWN0RWxlbWVudHMt Pml0ZW0oMCk7CisgICAgQVNTRVJUKG5vZGUtPmhhc1RhZ05hbWUoV2ViQ29yZTo6SFRNTE5hbWVz OjpvYmplY3RUYWcpKTsKKyAgICBXZWJDb3JlOjpXaWRnZXQqIHdpZGdldCA9IHN0YXRpY19jYXN0 PEhUTUxQbHVnSW5FbGVtZW50Kj4obm9kZSktPnBsdWdpbldpZGdldCgpOworICAgIGlmICghd2lk Z2V0KQorICAgICAgICByZXR1cm4gMDsKKyAgICBXZWJQbHVnaW4qIHBsdWdpbiA9IHN0YXRpY19j YXN0PFdlYlBsdWdpbkNvbnRhaW5lckltcGwqPih3aWRnZXQpLT5wbHVnaW4oKTsKKyAgICBBU1NF UlQocGx1Z2luKTsKKyAgICAvLyBJZiB0aGUgcGx1Z2luIGlzIGEgcGxhY2Vob2xkZXIsIGl0IGlz IG5vdCB1c2VmdWwgdG8gdGhlIGNhbGxlciwgYW5kIGl0CisgICAgLy8gY291bGQgYmUgcmVwbGFj ZWQgYXQgYW55IHRpbWUuIFRoZXJlZm9yZSwgZG8gbm90IHJldHVybiBpdC4KKyAgICBpZiAocGx1 Z2luLT5pc1BsYWNlaG9sZGVyKCkpCisgICAgICAgIHJldHVybiAwOworCisgICAgLy8gVGhlIHBs dWdpbiB3YXMgaW5zdGFudGlhdGVkIGFuZCB3aWxsIG91dGxpdmUgdGhpcyBvYmplY3QuCisgICAg cmV0dXJuIHBsdWdpbjsKK30KKwogYm9vbCBXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0UGFnZShX ZWJLaXQ6OldlYlZpZXdJbXBsKiB3ZWJWaWV3LCBjb25zdCBTdHJpbmcmIHBsdWdpblR5cGUpCiB7 CiAgICAgUGFnZTo6UGFnZUNsaWVudHMgcGFnZUNsaWVudHM7CkBAIC0xNTcsNyArMTg2LDcgQEAg Ym9vbCBXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0UGFnZShXZWJLaXQ6OldlYlZpZXdJbXBsKiB3 ZWJWaWV3LCBjb25zdCBTdHJpbmcmIHAKIAogICAgIHdlYlZpZXctPmNsaWVudCgpLT5pbml0aWFs aXplSGVscGVyUGx1Z2luV2ViRnJhbWUodGhpcyk7CiAKLSAgICAvLyBUaGUgcGFnZSdzIG1haW4g ZnJhbWUgd2FzIHNldCBpbiBpbml0aWFsaXplTWFpbkZyYW1lKCkgYXMgYSByZXN1bHQgb2YgdGhl IGFib3ZlIGNhbGwuCisgICAgLy8gVGhlIHBhZ2UncyBtYWluIGZyYW1lIHdhcyBzZXQgaW4gaW5p dGlhbGl6ZUZyYW1lKCkgYXMgYSByZXN1bHQgb2YgdGhlIGFib3ZlIGNhbGwuCiAgICAgRnJhbWUq IGZyYW1lID0gbV9wYWdlLT5tYWluRnJhbWUoKTsKICAgICBBU1NFUlQoZnJhbWUpOwogICAgIGZy YW1lLT5zZXRWaWV3KEZyYW1lVmlldzo6Y3JlYXRlKGZyYW1lKSk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmggYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmgKaW5kZXggNmJkZDMzNTJmMTFm MjJkNWVkM2UxZDQ0NTFkYzA4YzM0MTk3NzY5ZS4uMmViMjhlYzMxMGU1NjUxMWQwZTNmODQyNjhi ZTcwNmZhZTMwZDczOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi SGVscGVyUGx1Z2luSW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhl bHBlclBsdWdpbkltcGwuaApAQCAtNDIsNyArNDIsNiBAQCBjbGFzcyBQYWdlOwogbmFtZXNwYWNl IFdlYktpdCB7CiAKIGNsYXNzIEhlbHBlclBsdWdpbkNocm9tZUNsaWVudDsKLWNsYXNzIFdlYkZy YW1lSW1wbDsKIGNsYXNzIFdlYlZpZXdJbXBsOwogY2xhc3MgV2ViV2lkZ2V0Q2xpZW50OwogCkBA IC02MCw2ICs1OSw3IEBAIHB1YmxpYzoKIAogICAgIC8vIFdlYkhlbHBlclBsdWdpbiBtZXRob2Rz OgogICAgIHZpcnR1YWwgdm9pZCBpbml0aWFsaXplRnJhbWUoV2ViRnJhbWVDbGllbnQqKSBPVkVS UklERTsKKyAgICB2aXJ0dWFsIFdlYlBsdWdpbiogZ2V0UGx1Z2luKCkgT1ZFUlJJREU7CiAKIHBy aXZhdGU6CiAgICAgZXhwbGljaXQgV2ViSGVscGVyUGx1Z2luSW1wbChXZWJXaWRnZXRDbGllbnQq KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVy Q2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXll ckNsaWVudEltcGwuY3BwCmluZGV4IDQwYmU0ZDZkMzQ3ZjM3YTk3ZmJiNzZiNDlhN2Y0YzBmNTAz N2U2ODguLmYwZGNhY2IwYTNkN2NkYWY5NjZjY2ZlMWEyNzQ5OTUyZGUzMmQ3M2QgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5j cHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJ bXBsLmNwcApAQCAtMjY4LDExICsyNjgsMjMgQEAgdm9pZCBXZWJNZWRpYVBsYXllckNsaWVudElt cGw6OmtleU5lZWRlZChjb25zdCBXZWJTdHJpbmcmIGtleVN5c3RlbSwgY29uc3QgV2ViU3QKICNl bmRpZgogfQogCi12b2lkIFdlYk1lZGlhUGxheWVyQ2xpZW50SW1wbDo6Y3JlYXRlSGVscGVyUGx1 Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUqIGZyYW1lKQorV2ViUGx1 Z2luKiBXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBX ZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKiBmcmFtZSkKIHsKICAgICBBU1NFUlQoIW1f aGVscGVyUGx1Z2luKTsKICAgICBXZWJWaWV3SW1wbCogd2ViVmlldyA9IHN0YXRpY19jYXN0PFdl YlZpZXdJbXBsKj4oZnJhbWUtPnZpZXcoKSk7CiAgICAgbV9oZWxwZXJQbHVnaW4gPSB3ZWJWaWV3 LT5jcmVhdGVIZWxwZXJQbHVnaW4ocGx1Z2luVHlwZSk7CisgICAgaWYgKCFtX2hlbHBlclBsdWdp bikKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBXZWJQbHVnaW4qIHBsdWdpbiA9IG1faGVscGVy UGx1Z2luLT5nZXRQbHVnaW4oKTsKKyAgICBpZiAoIXBsdWdpbikgeworICAgICAgICAvLyBUaGVy ZSBpcyBubyBuZWVkIHRvIGtlZXAgdGhlIGhlbHBlciBwbHVnaW4gYXJvdW5kIGFuZCB0aGUgY2Fs bGVyCisgICAgICAgIC8vIHNob3VsZCBub3QgYmUgZXhwZWN0ZWQgdG8gY2FsbCBjbG9zZSBhZnRl ciBhIGZhaWx1cmUgKG51bGwgcG9pbnRlcikuCisgICAgICAgIGNsb3NlSGVscGVyUGx1Z2luKCk7 CisgICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIHJldHVybiBwbHVnaW47CiB9CiAKIHZv aWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjpjbG9zZUhlbHBlclBsdWdpbigpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwu aCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5o CmluZGV4IDkwMmRkYzgzNDdiMWFjNTBhNWE2ZDBjYzY2NTBiNzMyNzAxZDgzZjIuLmMxOTdmZmQ5 OTdjMTBhMWExYzJjM2Y5ZTU2ZmZkYjhhOTIzYWMxMzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oCkBAIC05MCw3ICs5 MCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQga2V5RXJyb3IoY29uc3QgV2ViU3RyaW5n JiBrZXlTeXN0ZW0sIGNvbnN0IFdlYlN0cmluZyYgc2Vzc2lvbklkLCBNZWRpYUtleUVycm9yQ29k ZSwgdW5zaWduZWQgc2hvcnQgc3lzdGVtQ29kZSk7CiAgICAgdmlydHVhbCB2b2lkIGtleU1lc3Nh Z2UoY29uc3QgV2ViU3RyaW5nJiBrZXlTeXN0ZW0sIGNvbnN0IFdlYlN0cmluZyYgc2Vzc2lvbklk LCBjb25zdCB1bnNpZ25lZCBjaGFyKiBtZXNzYWdlLCB1bnNpZ25lZCBtZXNzYWdlTGVuZ3RoKTsK ICAgICB2aXJ0dWFsIHZvaWQga2V5TmVlZGVkKGNvbnN0IFdlYlN0cmluZyYga2V5U3lzdGVtLCBj b25zdCBXZWJTdHJpbmcmIHNlc3Npb25JZCwgY29uc3QgdW5zaWduZWQgY2hhciogaW5pdERhdGEs IHVuc2lnbmVkIGluaXREYXRhTGVuZ3RoKTsKLSAgICB2aXJ0dWFsIHZvaWQgY3JlYXRlSGVscGVy UGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2luVHlwZSwgV2ViRnJhbWUqKTsKKyAgICB2aXJ0 dWFsIFdlYlBsdWdpbiogY3JlYXRlSGVscGVyUGx1Z2luKGNvbnN0IFdlYlN0cmluZyYgcGx1Z2lu VHlwZSwgV2ViRnJhbWUqKTsKICAgICB2aXJ0dWFsIHZvaWQgY2xvc2VIZWxwZXJQbHVnaW4oKTsK ICAgICB2aXJ0dWFsIHZvaWQgZGlzYWJsZUFjY2VsZXJhdGVkQ29tcG9zaXRpbmcoKTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViUGFnZVBvcHVwSW1wbC5jcHAg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJQYWdlUG9wdXBJbXBsLmNwcAppbmRleCBh ZTVhYWM4YTQwNzNmYjU4NzFkOTczNGQ3ZjQ0NzdjYWJmY2VjMzZkLi4wZTUwYWZlMjRhZTFkYTcz MzBjN2ZiNTk4MDAxOGI3ZWNjZTViNDJjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJQYWdlUG9wdXBJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJQYWdlUG9wdXBJbXBsLmNwcApAQCAtMzYsMTMgKzM2LDExIEBACiAjaW5jbHVkZSAi RG9jdW1lbnRMb2FkZXIuaCIKICNpbmNsdWRlICJFbXB0eUNsaWVudHMuaCIKICNpbmNsdWRlICJG b2N1c0NvbnRyb2xsZXIuaCIKLSNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmll dy5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRlICJQYWdlUG9wdXBDbGllbnQuaCIKICNp bmNsdWRlICJQYWdlV2lkZ2V0RGVsZWdhdGUuaCIKICNpbmNsdWRlICJTZXR0aW5ncy5oIgotI2lu Y2x1ZGUgIldlYklucHV0RXZlbnQuaCIKICNpbmNsdWRlICJXZWJJbnB1dEV2ZW50Q29udmVyc2lv bi5oIgogI2luY2x1ZGUgIldlYlBhZ2VQb3B1cC5oIgogI2luY2x1ZGUgIldlYlZpZXdJbXBsLmgi CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNTQy ODgwZTdkNzg4YmI1YzNhNjhkYmEzZjAzMmU3NjJiOThhNmEwMi4uYzRhNTQ2MDk5ZjMyYTU3MTJh YTVmYjhhMzA5OGMxMWQ2OTQ2MWZlMiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBi L1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTA2LTA2ICBEYXZpZCBEb3J3 aW4gIDxkZG9yd2luQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIFByb3ZpZGUg YWNjZXNzIHRvIHRoZSBXZWJQbHVnaW4gY3JlYXRlZCBieSB0aGUgaGVscGVyIHBsdWdpbiB3aWRn ZXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4MDI4 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQg aXNQbGFjZWhvbGRlcigpIHRvIFdlYlBsdWdpbi4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVl L2Nocm9taXVtL1Rlc3RXZWJQbHVnaW4uaDoKKyAgICAgICAgKFRlc3RXZWJQbHVnaW46OmlzUGxh Y2Vob2xkZXIpOgorCiAyMDEyLTA2LTA1ICBKb24gTGVlICA8am9ubGVlQGFwcGxlLmNvbT4KIAog ICAgICAgICBCdWlsZGJvdCBmaXguCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9UZXN0V2ViUGx1Z2luLmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9U ZXN0V2ViUGx1Z2luLmgKaW5kZXggODU4MTI4OGFjYjY4YjBkMDc5MzhjZWNkOWFmNWUzNzUzNmY2 YmIxOS4uNGM5ZjJmNGQyMjg1NzljY2Y2YTE2NDU2YmYwYWQzNDRjYWQ4OWY3MCAxMDA2NDQKLS0t IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYlBsdWdpbi5oCisrKyBiL1Rv b2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJQbHVnaW4uaApAQCAtNjgsNiArNjgs NyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRpZEZhaWxMb2FkaW5nKGNvbnN0IFdlYktp dDo6V2ViVVJMRXJyb3ImKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgZGlkRmluaXNoTG9hZGluZ0Zy YW1lUmVxdWVzdChjb25zdCBXZWJLaXQ6OldlYlVSTCYsIHZvaWQqIG5vdGlmeURhdGEpIHsgfQog ICAgIHZpcnR1YWwgdm9pZCBkaWRGYWlsTG9hZGluZ0ZyYW1lUmVxdWVzdChjb25zdCBXZWJLaXQ6 OldlYlVSTCYsIHZvaWQqIG5vdGlmeURhdGEsIGNvbnN0IFdlYktpdDo6V2ViVVJMRXJyb3ImKSB7 IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNQbGFjZWhvbGRlcigpIHsgcmV0dXJuIGZhbHNlOyB9CiAK IHByaXZhdGU6CiAgICAgZW51bSBQcmltaXRpdmUgewo= 146442 2012-06-07 18:32:01 -0700 2012-06-11 11:14:32 -0700 Call frameDetached() from WebHelperPluginImpl::close() bug-88028-20120607183200.patch text/plain 12612 ddorwin U3VidmVyc2lvbiBSZXZpc2lvbjogMTE5NTMzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGI2NjJkNzY1YzcxZTc4NDE4OThlYmI4ZmQxNWZiMGJhNmZiZjNkYTUuLmI1NmZkNTdiZGU1ZWUy NGEwYTkwMmYyNWRjYTZiZDE4ZTU5OWEyMGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMzYgQEAKKzIwMTItMDYtMDcgIERhdmlkIERvcndpbiAgPGRkb3J3aW5AY2hyb21p dW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gUHJvdmlkZSBhY2Nlc3MgdG8gdGhlIFdlYlBs dWdpbiBjcmVhdGVkIGJ5IHRoZSBoZWxwZXIgcGx1Z2luIHdpZGdldAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODgwMjgKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBIFdlYlBsdWdpbiBpcyBjcmVhdGVkIHdo ZW4gdGhlIGRvY3VtZW50IGNyZWF0ZWQgYnkgY3JlYXRlSGVscGVyUGx1Z2luKCkgaXMgbGFpZCBv dXQuCisgICAgICAgIEV4cG9zZSBpdCBzbyB0aGUgZW1iZWRkZXIgY2FuIGludGVyYWN0IHdpdGgg dGhlIHBsdWdpbiBpbnN0YW5jZS4KKworICAgICAgICAqIHB1YmxpYy9XZWJIZWxwZXJQbHVnaW4u aDoKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJIZWxwZXJQbHVnaW4pOgorICAgICAg ICAqIHB1YmxpYy9XZWJNZWRpYVBsYXllckNsaWVudC5oOgorICAgICAgICAoV2ViS2l0KToKKyAg ICAgICAgKiBwdWJsaWMvV2ViUGx1Z2luLmg6CisgICAgICAgIChXZWJLaXQ6OldlYlBsdWdpbjo6 aXNQbGFjZWhvbGRlcik6CisgICAgICAgIChXZWJQbHVnaW4pOgorICAgICAgICAqIHNyYy9XZWJI ZWxwZXJQbHVnaW5JbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViSGVscGVyUGx1Z2luSW1w bDo6V2ViSGVscGVyUGx1Z2luSW1wbCk6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2Vi S2l0OjpXZWJIZWxwZXJQbHVnaW5JbXBsOjpnZXRQbHVnaW4pOgorICAgICAgICAoV2ViS2l0OjpX ZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0UGFnZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkhlbHBl clBsdWdpbkltcGw6OmNsb3NlKToKKyAgICAgICAgKiBzcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5o OgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYkhlbHBlclBsdWdpbkltcGwpOgorICAg ICAgICAqIHNyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwOgorICAgICAgICAoV2ViS2l0 OjpXZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNyZWF0ZUhlbHBlclBsdWdpbik6CisgICAgICAg ICogc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5oOgorICAgICAgICAoV2ViTWVkaWFQbGF5 ZXJDbGllbnRJbXBsKToKKyAgICAgICAgKiBzcmMvV2ViUGFnZVBvcHVwSW1wbC5jcHA6CisKIDIw MTItMDYtMDUgIE1hcmsgUGlsZ3JpbSAgPHBpbGdyaW1AY2hyb21pdW0ub3JnPgogCiAgICAgICAg IFtDaHJvbWl1bV0gTW92ZSBjcmVhdGVMb2NhbFN0b3JhZ2VOYW1lc3BhY2UgdG8gUGxhdGZvcm0u aApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSGVscGVyUGx1 Z2luLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJIZWxwZXJQbHVnaW4uaApp bmRleCBiNmNjMTdkMjY4YTE5ZTllMTc5NGQ0MzZmYjA3MjU3NmI5ODYzZjA1Li4zY2UxYTViYThj MDFkYTMzNzYyNGMyZjdhMmIxMWU2NjdmMzc2YWU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJIZWxwZXJQbHVnaW4uaAorKysgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3B1YmxpYy9XZWJIZWxwZXJQbHVnaW4uaApAQCAtMzcsNiArMzcsNyBAQAogbmFtZXNw YWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYkZyYW1lQ2xpZW50OworY2xhc3MgV2ViUGx1Z2luOwog Y2xhc3MgV2ViV2lkZ2V0Q2xpZW50OwogCiBjbGFzcyBXZWJIZWxwZXJQbHVnaW4gOiBwdWJsaWMg V2ViV2lkZ2V0IHsKQEAgLTQ1LDYgKzQ2LDExIEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9p ZCBpbml0aWFsaXplRnJhbWUoV2ViRnJhbWVDbGllbnQqKSA9IDA7CiAKKyAgICAvLyBUaGUgcmV0 dXJuZWQgcG9pbnRlciBtYXkgYmUgMCBldmVuIGlmIGluaXRpYWxpemF0aW9uIHdhcyBzdWNjZXNz ZnVsLgorICAgIC8vIEZvciBleGFtcGxlLCBpZiB0aGUgcGx1Z2luIGNhbm5vdCBiZSBmb3VuZCBv ciB0aGUgcGx1Z2luIGlzIGRpc2FibGVkLgorICAgIC8vIElmIG5vdCAwLCB0aGUgcmV0dXJuZWQg cG9pbnRlciBpcyB2YWxpZCBmb3IgdGhlIGxpZmV0aW1lIG9mIHRoaXMgb2JqZWN0LgorICAgIHZp cnR1YWwgV2ViUGx1Z2luKiBnZXRQbHVnaW4oKSA9IDA7CisKIHByb3RlY3RlZDoKICAgICB+V2Vi SGVscGVyUGx1Z2luKCkgeyB9CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9wdWJsaWMvV2ViTWVkaWFQbGF5ZXJDbGllbnQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYk1lZGlhUGxheWVyQ2xpZW50LmgKaW5kZXggYTQ2ZWU1Y2VkNDhhYzlmNTg1ZmMx ZGRkMjRmYTAyMjE4MmI0ZTE5OC4uMWQ5YzY0ZGM4MDYyNzVkMzliZGU1OTcyODdhOGNjMDJkZjlk MmNmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTWVkaWFQ bGF5ZXJDbGllbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNZWRp YVBsYXllckNsaWVudC5oCkBAIC0zNiw2ICszNiw3IEBACiBuYW1lc3BhY2UgV2ViS2l0IHsKIAog Y2xhc3MgV2ViRnJhbWU7CitjbGFzcyBXZWJQbHVnaW47CiBjbGFzcyBXZWJSZXF1ZXN0OwogY2xh c3MgV2ViVVJMOwogCkBAIC03Niw3ICs3Nyw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQg a2V5RXJyb3IoY29uc3QgV2ViU3RyaW5nJiwgY29uc3QgV2ViU3RyaW5nJiwgTWVkaWFLZXlFcnJv ckNvZGUsIHVuc2lnbmVkIHNob3J0IHN5c3RlbUNvZGUpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQg a2V5TWVzc2FnZShjb25zdCBXZWJTdHJpbmcmLCBjb25zdCBXZWJTdHJpbmcmLCBjb25zdCB1bnNp Z25lZCBjaGFyKiwgdW5zaWduZWQpID0gMDsKICAgICB2aXJ0dWFsIHZvaWQga2V5TmVlZGVkKGNv bnN0IFdlYlN0cmluZyYsIGNvbnN0IFdlYlN0cmluZyYsIGNvbnN0IHVuc2lnbmVkIGNoYXIqIGlu aXREYXRhLCB1bnNpZ25lZCBpbml0RGF0YUxlbmd0aCkgPSAwOwotICAgIHZpcnR1YWwgdm9pZCBj cmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSop ID0gMDsKKyAgICAvLyBUaGUgcmV0dXJuZWQgcG9pbnRlciBpcyB2YWxpZCB1bnRpbCBjbG9zZUhl bHBlclBsdWdpbigpIGlzIGNhbGxlZC4KKyAgICAvLyBSZXR1cm5zIDAgaWYgdGhlIHBsdWdpbiBj b3VsZCBub3QgYmUgaW5zdGFudGlhdGVkLgorICAgIHZpcnR1YWwgV2ViUGx1Z2luKiBjcmVhdGVI ZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5UeXBlLCBXZWJGcmFtZSopID0gMDsK ICAgICB2aXJ0dWFsIHZvaWQgY2xvc2VIZWxwZXJQbHVnaW4oKSA9IDA7CiAgICAgdmlydHVhbCB2 b2lkIGRpc2FibGVBY2NlbGVyYXRlZENvbXBvc2l0aW5nKCkgPSAwOwogcHJvdGVjdGVkOgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViUGx1Z2luLmggYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJQbHVnaW4uaAppbmRleCA1YjkxMWQwYjhmZTc2 ZGI3ZGQwMWYxODJjMzVlODljZjNhMWI2NWQ5Li41ZWY4ODRjNzNhM2JlOGRhYjlhMWZjZWNlZThi NThjZDE4Y2JmYzBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJQbHVnaW4uaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJQbHVnaW4u aApAQCAtMTM5LDYgKzEzOSw4IEBAIHB1YmxpYzoKICAgICAvLyBSb3RhdGVzIHRoZSBwbHVnaW4n cyB2aWV3IG9mIGl0cyBjb250ZW50LgogICAgIHZpcnR1YWwgdm9pZCByb3RhdGVWaWV3KFJvdGF0 aW9uVHlwZSB0eXBlKSB7IH0KIAorICAgIHZpcnR1YWwgYm9vbCBpc1BsYWNlaG9sZGVyKCkgeyBy ZXR1cm4gdHJ1ZTsgfQorCiBwcm90ZWN0ZWQ6CiAgICAgfldlYlBsdWdpbigpIHsgfQogfTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhlbHBlclBsdWdpbkltcGwu Y3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5jcHAK aW5kZXggMTU4MWRlYTI4OGM3OTQ5NmUyZDcxNzdmMmJhODU2ZjJjNmI2MzcxNy4uYWZhMzcwMWFh MjM0NzE3MjE5YjNhMmMxY2UyYTA1MTQxNjI4ZTgxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5jcHAKQEAgLTMxLDE1ICszMSwxOCBA QAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldlYkhlbHBlclBsdWdpbkltcGwuaCIK IAotI2luY2x1ZGUgIkNocm9tZS5oIgogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgiCiAjaW5j bHVkZSAiRW1wdHlDbGllbnRzLmgiCiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgiCiAjaW5j bHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiSFRNTFBsdWdJbkVsZW1lbnQuaCIKKyNpbmNs dWRlICJOb2RlTGlzdC5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKICNpbmNsdWRlICJQYWdlV2lkZ2V0 RGVsZWdhdGUuaCIKICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1w bC5oIgorI2luY2x1ZGUgIldlYlBsdWdpbi5oIgorI2luY2x1ZGUgIldlYlBsdWdpbkNvbnRhaW5l ckltcGwuaCIKICNpbmNsdWRlICJXZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViVmlld0lt cGwuaCIKICNpbmNsdWRlICJXZWJXaWRnZXRDbGllbnQuaCIKQEAgLTk5LDYgKzEwMiw3IEBAIHBy aXZhdGU6CiAKIFdlYkhlbHBlclBsdWdpbkltcGw6OldlYkhlbHBlclBsdWdpbkltcGwoV2ViV2lk Z2V0Q2xpZW50KiBjbGllbnQpCiAgICAgOiBtX3dpZGdldENsaWVudChjbGllbnQpCisgICAgLCBt X3dlYlZpZXcoMCkKIHsKICAgICBBU1NFUlQoY2xpZW50KTsKIH0KQEAgLTE0Myw2ICsxNDcsMzEg QEAgdm9pZCBXZWJIZWxwZXJQbHVnaW5JbXBsOjppbml0aWFsaXplRnJhbWUoV2ViRnJhbWVDbGll bnQqIGNsaWVudCkKICAgICBmcmFtZS0+aW5pdGlhbGl6ZUFzTWFpbkZyYW1lKG1fcGFnZS5nZXQo KSk7CiB9CiAKKy8vIFJldHVybnMgYSBwb2ludGVyIHRvIHRoZSBXZWJQbHVnaW4gYnkgZmluZGlu ZyB0aGUgc2luZ2xlIDxvYmplY3Q+IHRhZyBpbiB0aGUgcGFnZS4KK1dlYlBsdWdpbiogV2ViSGVs cGVyUGx1Z2luSW1wbDo6Z2V0UGx1Z2luKCkKK3sKKyAgICBBU1NFUlQobV9wYWdlKTsKKworICAg IFJlZlB0cjxOb2RlTGlzdD4gb2JqZWN0RWxlbWVudHMgPSBtX3BhZ2UtPm1haW5GcmFtZSgpLT5k b2N1bWVudCgpLT5nZXRFbGVtZW50c0J5VGFnTmFtZShXZWJDb3JlOjpIVE1MTmFtZXM6Om9iamVj dFRhZy5sb2NhbE5hbWUoKSk7CisgICAgQVNTRVJUKG9iamVjdEVsZW1lbnRzICYmIG9iamVjdEVs ZW1lbnRzLT5sZW5ndGgoKSA9PSAxKTsKKyAgICBpZiAoIW9iamVjdEVsZW1lbnRzIHx8IG9iamVj dEVsZW1lbnRzLT5sZW5ndGgoKSA8IDEpCisgICAgICAgIHJldHVybiAwOworICAgIE5vZGUqIG5v ZGUgPSBvYmplY3RFbGVtZW50cy0+aXRlbSgwKTsKKyAgICBBU1NFUlQobm9kZS0+aGFzVGFnTmFt ZShXZWJDb3JlOjpIVE1MTmFtZXM6Om9iamVjdFRhZykpOworICAgIFdlYkNvcmU6OldpZGdldCog d2lkZ2V0ID0gc3RhdGljX2Nhc3Q8SFRNTFBsdWdJbkVsZW1lbnQqPihub2RlKS0+cGx1Z2luV2lk Z2V0KCk7CisgICAgaWYgKCF3aWRnZXQpCisgICAgICAgIHJldHVybiAwOworICAgIFdlYlBsdWdp biogcGx1Z2luID0gc3RhdGljX2Nhc3Q8V2ViUGx1Z2luQ29udGFpbmVySW1wbCo+KHdpZGdldCkt PnBsdWdpbigpOworICAgIEFTU0VSVChwbHVnaW4pOworICAgIC8vIElmIHRoZSBwbHVnaW4gaXMg YSBwbGFjZWhvbGRlciwgaXQgaXMgbm90IHVzZWZ1bCB0byB0aGUgY2FsbGVyLCBhbmQgaXQKKyAg ICAvLyBjb3VsZCBiZSByZXBsYWNlZCBhdCBhbnkgdGltZS4gVGhlcmVmb3JlLCBkbyBub3QgcmV0 dXJuIGl0LgorICAgIGlmIChwbHVnaW4tPmlzUGxhY2Vob2xkZXIoKSkKKyAgICAgICAgcmV0dXJu IDA7CisKKyAgICAvLyBUaGUgcGx1Z2luIHdhcyBpbnN0YW50aWF0ZWQgYW5kIHdpbGwgb3V0bGl2 ZSB0aGlzIG9iamVjdC4KKyAgICByZXR1cm4gcGx1Z2luOworfQorCiBib29sIFdlYkhlbHBlclBs dWdpbkltcGw6OmluaXRQYWdlKFdlYktpdDo6V2ViVmlld0ltcGwqIHdlYlZpZXcsIGNvbnN0IFN0 cmluZyYgcGx1Z2luVHlwZSkKIHsKICAgICBQYWdlOjpQYWdlQ2xpZW50cyBwYWdlQ2xpZW50czsK QEAgLTE1Nyw3ICsxODYsNyBAQCBib29sIFdlYkhlbHBlclBsdWdpbkltcGw6OmluaXRQYWdlKFdl YktpdDo6V2ViVmlld0ltcGwqIHdlYlZpZXcsIGNvbnN0IFN0cmluZyYgcAogCiAgICAgd2ViVmll dy0+Y2xpZW50KCktPmluaXRpYWxpemVIZWxwZXJQbHVnaW5XZWJGcmFtZSh0aGlzKTsKIAotICAg IC8vIFRoZSBwYWdlJ3MgbWFpbiBmcmFtZSB3YXMgc2V0IGluIGluaXRpYWxpemVNYWluRnJhbWUo KSBhcyBhIHJlc3VsdCBvZiB0aGUgYWJvdmUgY2FsbC4KKyAgICAvLyBUaGUgcGFnZSdzIG1haW4g ZnJhbWUgd2FzIHNldCBpbiBpbml0aWFsaXplRnJhbWUoKSBhcyBhIHJlc3VsdCBvZiB0aGUgYWJv dmUgY2FsbC4KICAgICBGcmFtZSogZnJhbWUgPSBtX3BhZ2UtPm1haW5GcmFtZSgpOwogICAgIEFT U0VSVChmcmFtZSk7CiAgICAgZnJhbWUtPnNldFZpZXcoRnJhbWVWaWV3OjpjcmVhdGUoZnJhbWUp KTsKQEAgLTE5Myw3ICsyMjIsMTcgQEAgdm9pZCBXZWJIZWxwZXJQbHVnaW5JbXBsOjpzZXRGb2N1 cyhib29sIGVuYWJsZSkKIAogdm9pZCBXZWJIZWxwZXJQbHVnaW5JbXBsOjpjbG9zZSgpCiB7Ci0g ICAgbV9wYWdlLmNsZWFyKCk7CisgICAgUmVmUHRyPFdlYkZyYW1lSW1wbD4gbWFpbkZyYW1lSW1w bDsKKworICAgIGlmIChtX3BhZ2UpIHsKKyAgICAgICAgLy8gSW5pdGlhdGUgc2h1dGRvd24uIFRo aXMgd2lsbCBjYXVzZSBhIGxvdCBvZiBub3RpZmljYXRpb25zIHRvIGJlIHNlbnQuCisgICAgICAg IGlmIChtX3BhZ2UtPm1haW5GcmFtZSgpKSB7CisgICAgICAgICAgICBtYWluRnJhbWVJbXBsID0g V2ViRnJhbWVJbXBsOjpmcm9tRnJhbWUobV9wYWdlLT5tYWluRnJhbWUoKSk7CisgICAgICAgICAg ICBtX3BhZ2UtPm1haW5GcmFtZSgpLT5sb2FkZXIoKS0+ZnJhbWVEZXRhY2hlZCgpOworICAgICAg ICB9CisgICAgICAgIG1fcGFnZS5jbGVhcigpOworICAgIH0KKwogICAgIG1fd2lkZ2V0Q2xpZW50 ID0gMDsKICAgICBkZXJlZigpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViSGVscGVyUGx1Z2luSW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViSGVscGVyUGx1Z2luSW1wbC5oCmluZGV4IDZiZGQzMzUyZjExZjIyZDVlZDNlMWQ0NDUxZGMw OGMzNDE5Nzc2OWUuLjJlYjI4ZWMzMTBlNTY1MTFkMGUzZjg0MjY4YmU3MDZmYWUzMGQ3MzkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhlbHBlclBsdWdpbkltcGwu aAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIZWxwZXJQbHVnaW5JbXBsLmgK QEAgLTQyLDcgKzQyLDYgQEAgY2xhc3MgUGFnZTsKIG5hbWVzcGFjZSBXZWJLaXQgewogCiBjbGFz cyBIZWxwZXJQbHVnaW5DaHJvbWVDbGllbnQ7Ci1jbGFzcyBXZWJGcmFtZUltcGw7CiBjbGFzcyBX ZWJWaWV3SW1wbDsKIGNsYXNzIFdlYldpZGdldENsaWVudDsKIApAQCAtNjAsNiArNTksNyBAQCBw dWJsaWM6CiAKICAgICAvLyBXZWJIZWxwZXJQbHVnaW4gbWV0aG9kczoKICAgICB2aXJ0dWFsIHZv aWQgaW5pdGlhbGl6ZUZyYW1lKFdlYkZyYW1lQ2xpZW50KikgT1ZFUlJJREU7CisgICAgdmlydHVh bCBXZWJQbHVnaW4qIGdldFBsdWdpbigpIE9WRVJSSURFOwogCiBwcml2YXRlOgogICAgIGV4cGxp Y2l0IFdlYkhlbHBlclBsdWdpbkltcGwoV2ViV2lkZ2V0Q2xpZW50Kik7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmNwcApp bmRleCA0MGJlNGQ2ZDM0N2YzN2E5N2ZiYjc2YjQ5YTdmNGMwZjUwMzdlNjg4Li5mMGRjYWNiMGEz ZDdjZGFmOTY2Y2NmZTFhMjc0OTk1MmRlMzJkNzNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAKQEAgLTI2OCwx MSArMjY4LDIzIEBAIHZvaWQgV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsOjprZXlOZWVkZWQoY29u c3QgV2ViU3RyaW5nJiBrZXlTeXN0ZW0sIGNvbnN0IFdlYlN0CiAjZW5kaWYKIH0KIAotdm9pZCBX ZWJNZWRpYVBsYXllckNsaWVudEltcGw6OmNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJp bmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKiBmcmFtZSkKK1dlYlBsdWdpbiogV2ViTWVkaWFQbGF5 ZXJDbGllbnRJbXBsOjpjcmVhdGVIZWxwZXJQbHVnaW4oY29uc3QgV2ViU3RyaW5nJiBwbHVnaW5U eXBlLCBXZWJGcmFtZSogZnJhbWUpCiB7CiAgICAgQVNTRVJUKCFtX2hlbHBlclBsdWdpbik7CiAg ICAgV2ViVmlld0ltcGwqIHdlYlZpZXcgPSBzdGF0aWNfY2FzdDxXZWJWaWV3SW1wbCo+KGZyYW1l LT52aWV3KCkpOwogICAgIG1faGVscGVyUGx1Z2luID0gd2ViVmlldy0+Y3JlYXRlSGVscGVyUGx1 Z2luKHBsdWdpblR5cGUpOworICAgIGlmICghbV9oZWxwZXJQbHVnaW4pCisgICAgICAgIHJldHVy biAwOworCisgICAgV2ViUGx1Z2luKiBwbHVnaW4gPSBtX2hlbHBlclBsdWdpbi0+Z2V0UGx1Z2lu KCk7CisgICAgaWYgKCFwbHVnaW4pIHsKKyAgICAgICAgLy8gVGhlcmUgaXMgbm8gbmVlZCB0byBr ZWVwIHRoZSBoZWxwZXIgcGx1Z2luIGFyb3VuZCBhbmQgdGhlIGNhbGxlcgorICAgICAgICAvLyBz aG91bGQgbm90IGJlIGV4cGVjdGVkIHRvIGNhbGwgY2xvc2UgYWZ0ZXIgYSBmYWlsdXJlIChudWxs IHBvaW50ZXIpLgorICAgICAgICBjbG9zZUhlbHBlclBsdWdpbigpOworICAgICAgICByZXR1cm4g MDsKKyAgICB9CisKKyAgICByZXR1cm4gcGx1Z2luOwogfQogCiB2b2lkIFdlYk1lZGlhUGxheWVy Q2xpZW50SW1wbDo6Y2xvc2VIZWxwZXJQbHVnaW4oKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmggYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaAppbmRleCA5MDJkZGM4MzQ3 YjFhYzUwYTVhNmQwY2M2NjUwYjczMjcwMWQ4M2YyLi5jMTk3ZmZkOTk3YzEwYTFhMWMyYzNmOWU1 NmZmZGI4YTkyM2FjMTMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJNZWRpYVBsYXllckNsaWVudEltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJNZWRpYVBsYXllckNsaWVudEltcGwuaApAQCAtOTAsNyArOTAsNyBAQCBwdWJsaWM6CiAg ICAgdmlydHVhbCB2b2lkIGtleUVycm9yKGNvbnN0IFdlYlN0cmluZyYga2V5U3lzdGVtLCBjb25z dCBXZWJTdHJpbmcmIHNlc3Npb25JZCwgTWVkaWFLZXlFcnJvckNvZGUsIHVuc2lnbmVkIHNob3J0 IHN5c3RlbUNvZGUpOwogICAgIHZpcnR1YWwgdm9pZCBrZXlNZXNzYWdlKGNvbnN0IFdlYlN0cmlu ZyYga2V5U3lzdGVtLCBjb25zdCBXZWJTdHJpbmcmIHNlc3Npb25JZCwgY29uc3QgdW5zaWduZWQg Y2hhciogbWVzc2FnZSwgdW5zaWduZWQgbWVzc2FnZUxlbmd0aCk7CiAgICAgdmlydHVhbCB2b2lk IGtleU5lZWRlZChjb25zdCBXZWJTdHJpbmcmIGtleVN5c3RlbSwgY29uc3QgV2ViU3RyaW5nJiBz ZXNzaW9uSWQsIGNvbnN0IHVuc2lnbmVkIGNoYXIqIGluaXREYXRhLCB1bnNpZ25lZCBpbml0RGF0 YUxlbmd0aCk7Ci0gICAgdmlydHVhbCB2b2lkIGNyZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJT dHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKik7CisgICAgdmlydHVhbCBXZWJQbHVnaW4qIGNy ZWF0ZUhlbHBlclBsdWdpbihjb25zdCBXZWJTdHJpbmcmIHBsdWdpblR5cGUsIFdlYkZyYW1lKik7 CiAgICAgdmlydHVhbCB2b2lkIGNsb3NlSGVscGVyUGx1Z2luKCk7CiAgICAgdmlydHVhbCB2b2lk IGRpc2FibGVBY2NlbGVyYXRlZENvbXBvc2l0aW5nKCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYlBhZ2VQb3B1cEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViUGFnZVBvcHVwSW1wbC5jcHAKaW5kZXggYWU1YWFjOGE0MDczZmI1ODcx ZDk3MzRkN2Y0NDc3Y2FiZmNlYzM2ZC4uMGU1MGFmZTI0YWUxZGE3MzMwYzdmYjU5ODAwMThiN2Vj Y2U1YjQyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViUGFnZVBv cHVwSW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViUGFnZVBvcHVw SW1wbC5jcHAKQEAgLTM2LDEzICszNiwxMSBAQAogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgi CiAjaW5jbHVkZSAiRW1wdHlDbGllbnRzLmgiCiAjaW5jbHVkZSAiRm9jdXNDb250cm9sbGVyLmgi Ci0jaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJQ YWdlLmgiCiAjaW5jbHVkZSAiUGFnZVBvcHVwQ2xpZW50LmgiCiAjaW5jbHVkZSAiUGFnZVdpZGdl dERlbGVnYXRlLmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKLSNpbmNsdWRlICJXZWJJbnB1dEV2 ZW50LmgiCiAjaW5jbHVkZSAiV2ViSW5wdXRFdmVudENvbnZlcnNpb24uaCIKICNpbmNsdWRlICJX ZWJQYWdlUG9wdXAuaCIKICNpbmNsdWRlICJXZWJWaWV3SW1wbC5oIgpkaWZmIC0tZ2l0IGEvVG9v bHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDU0Mjg4MGU3ZDc4OGJiNWMzYTY4 ZGJhM2YwMzJlNzYyYjk4YTZhMDIuLjA2MGU2ZmRiMzRlOTMwOWVjNWU3YjhlNzI1ZTM4N2JiYjA3 YjgwZDYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNSBAQAorMjAxMi0wNi0wNyAgRGF2aWQgRG9yd2luICA8ZGRvcndpbkBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBQcm92aWRlIGFjY2VzcyB0byB0aGUgV2Vi UGx1Z2luIGNyZWF0ZWQgYnkgdGhlIGhlbHBlciBwbHVnaW4gd2lkZ2V0CisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04ODAyOAorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIGlzUGxhY2Vob2xkZXIoKSB0 byBXZWJQbHVnaW4uCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9UZXN0V2Vi UGx1Z2luLmg6CisgICAgICAgIChUZXN0V2ViUGx1Z2luOjppc1BsYWNlaG9sZGVyKToKKwogMjAx Mi0wNi0wNSAgSm9uIExlZSAgPGpvbmxlZUBhcHBsZS5jb20+CiAKICAgICAgICAgQnVpbGRib3Qg Zml4LgpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYlBs dWdpbi5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vVGVzdFdlYlBsdWdpbi5oCmlu ZGV4IDg1ODEyODhhY2I2OGIwZDA3OTM4Y2VjZDlhZjVlMzc1MzZmNmJiMTkuLjRjOWYyZjRkMjI4 NTc5Y2NmNmExNjQ1NmJmMGFkMzQ0Y2FkODlmNzAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL2Nocm9taXVtL1Rlc3RXZWJQbHVnaW4uaAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9UZXN0V2ViUGx1Z2luLmgKQEAgLTY4LDYgKzY4LDcgQEAgcHVibGljOgogICAg IHZpcnR1YWwgdm9pZCBkaWRGYWlsTG9hZGluZyhjb25zdCBXZWJLaXQ6OldlYlVSTEVycm9yJikg eyB9CiAgICAgdmlydHVhbCB2b2lkIGRpZEZpbmlzaExvYWRpbmdGcmFtZVJlcXVlc3QoY29uc3Qg V2ViS2l0OjpXZWJVUkwmLCB2b2lkKiBub3RpZnlEYXRhKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQg ZGlkRmFpbExvYWRpbmdGcmFtZVJlcXVlc3QoY29uc3QgV2ViS2l0OjpXZWJVUkwmLCB2b2lkKiBu b3RpZnlEYXRhLCBjb25zdCBXZWJLaXQ6OldlYlVSTEVycm9yJikgeyB9CisgICAgdmlydHVhbCBi b29sIGlzUGxhY2Vob2xkZXIoKSB7IHJldHVybiBmYWxzZTsgfQogCiBwcml2YXRlOgogICAgIGVu dW0gUHJpbWl0aXZlIHsK