22898 2008-12-17 01:36:52 -0800 [GTK] need proper API for printing 2009-04-13 11:59:02 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC All RESOLVED FIXED Cairo, Gtk P2 Enhancement --- 24961 1 colin webkit-unassigned alp chpe christian gustavo oldest_to_newest 102758 0 colin 2008-12-17 01:36:52 -0800 Hello, I'm looking at webkit-gtk to create an "html2pdf" based on the webkit engine. For this, I'd like to be able to batch-print frames to files without having to click on Print every time. The attached patch does that. I hope including it could be possible! 102759 1 26088 colin 2008-12-17 01:37:44 -0800 Created attachment 26088 Patch to print frames directly to file 102802 2 26088 zecke 2008-12-17 13:08:33 -0800 Comment on attachment 26088 Patch to print frames directly to file > Index: WebKit/gtk/webkit/webkitwebframe.cpp > =================================================================== > --- WebKit/gtk/webkit/webkitwebframe.cpp (revision 39335) > +++ WebKit/gtk/webkit/webkitwebframe.cpp (working copy) > @@ -580,6 +580,45 @@ > } > } > > + > +void webkit_web_frame_print_to_file(WebKitWebFrame* frame, GtkPrintSettings *settings, GtkPageSetup *setup, const gchar *filename) > +{ > + gtk_print_operation_set_export_filename(op, filename); > + if (page_setup) > + gtk_print_operation_set_default_page_setup(op, page_setup); this does compile? I was not able to resolve page_setup, maybe the compiler is more clever than me. We will also need to consider making this official API... 102808 3 26101 colin 2008-12-17 13:41:42 -0800 Created attachment 26101 Fixed patch Hum, indeed, I don't how I managed to send this broken patch ^^ This one should be better. 102825 4 zecke 2008-12-17 15:39:25 -0800 Okay the patch seems fine. My two random complains are: - We should consider making it public API - we should not run an error dialog but maybe use GError as an out param? E.g. if you automate form printing you do not want to be blocked by an error dialog... what do you think? 102858 5 colin 2008-12-17 22:38:23 -0800 (In reply to comment #4) > Okay the patch seems fine. My two random complains are: > - We should consider making it public API Would be nice :) > - we should not run an error dialog but maybe use GError as an out param? > E.g. if you automate form printing you do not want to be blocked by an error > dialog... Good idea, yes. I can update the patch if you want ! 102871 6 26119 colin 2008-12-18 01:02:42 -0800 Created attachment 26119 Patch that completes and makes GtkPrint API public Hello, Here's a rather bigger patch that aims to complete the GtkPrint API and make it public. What it does: - WebKit/gtk/webkit/webkitwebframe.cpp: Factorizes code between print and print_to_file, as little of it changes in both cases; Removes the error dialog, leaving error handling to the caller; Adds the ability to specify page setup and print settings in the Print case too, which lets the calling app have a "Page setup" menu, and let it get back updated print settings in order to remember them. This adds a few parameters to the functions, but helps applications to have a full implementation; and add my name to the Copyright boiler-plate. - WebKit/gtk/webkit/webkitwebframe.h: Make the API public; the only annoyance is that the API will be different whether compiled against GTK 2.10+ or not, as the parameters type didn't exist before, it's not possible anymore to have filler-functions printing a g_warning(). - WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp: Update code to use the new API, with the minimal changes needed - just error handling the same way as it was before, only at the caller level. I tried to think of possible shortcomings to this API, because we wouldn't want to modify a public API, but I think it's complete. _print_to_file() shows no dialog, so there's no possibility to have updated settings after. GtkPageSetup can't be modified from inside a print dialog, so there are no modifications to get. 102872 7 colin 2008-12-18 01:06:33 -0800 For completeness, here's the start of the app I'm doing, which can provide testing of the changes (both webkit_web_frame_print_to_file and webkit_web_frame_print() are used). Its code is unclean and unfinished, but it demonstrates the thing :) http://colino.net/tmp/webkit2pdf-0.1cvs1.tar.gz 102990 8 26119 zecke 2008-12-19 09:11:02 -0800 Comment on attachment 26119 Patch that completes and makes GtkPrint API public Please see http://webkit.org/coding/contributing.html on Coding Style, how to prepare a ChangeLog, etc... For the style issues and the lack of ChangeLog I set this to r=-. > - webkit_web_frame_print(kit(frame)); > + GError *error = NULL; > + webkit_web_frame_print(kit(frame), NULL, NULL, &error, NULL); > + if (error) { > + GtkWidget* topLevel = gtk_widget_get_toplevel(GTK_WIDGET(webkit_web_frame_get_web_view(kit(frame)))); > + if (!GTK_WIDGET_TOPLEVEL(topLevel)) indention is completely wrong. Four spaces. So the topLevel would already be at level 8... So please use the right amount of spaces with a simple if (!error) return; you just avoid deeply nested code, this is something that me and others aim for. Please try to avoid the usage of NULL in C++, it is not well defined. > void ChromeClient::exceededDatabaseQuota(Frame* frame, const String&) > Index: WebKit/gtk/webkit/webkitwebframe.cpp > =================================================================== > --- WebKit/gtk/webkit/webkitwebframe.cpp (revision 39335) > +++ WebKit/gtk/webkit/webkitwebframe.cpp (working copy) > @@ -5,6 +5,7 @@ > * Copyright (C) 2008 Christian Dywan <christian@imendio.com> > * Copyright (C) 2008 Collabora Ltd. > * Copyright (C) 2008 Nuanti Ltd. > + * Copyright (C) 2008 Colin Leroy <colin@colino.net>. > * > * This library is free software; you can redistribute it and/or > * modify it under the terms of the GNU Library General Public > @@ -548,7 +549,7 @@ > printContext->end(); > } > > -void webkit_web_frame_print(WebKitWebFrame* frame) > +static void frame_print(WebKitWebFrame* frame, GtkPrintSettings *settings, GtkPageSetup *page_setup, const gchar *filename, GError **error, GtkPrintSettings **updated_settings) > { > GtkWidget* topLevel = gtk_widget_get_toplevel(GTK_WIDGET(webkit_web_frame_get_web_view(frame))); > if (!GTK_WIDGET_TOPLEVEL(topLevel)) > @@ -558,33 +559,66 @@ > ASSERT(coreFrame); > > PrintContext printContext(coreFrame); > + GtkPrintOperationAction action; > > GtkPrintOperation* op = gtk_print_operation_new(); > - g_signal_connect(op, "begin-print", G_CALLBACK(begin_print), &printContext); > - g_signal_connect(op, "draw-page", G_CALLBACK(draw_page), &printContext); > - g_signal_connect(op, "end-print", G_CALLBACK(end_print), &printContext); > - GError *error = NULL; > - gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, GTK_WINDOW(topLevel), &error); > - g_object_unref(op); > + g_signal_connect(G_OBJECT(op), "begin-print", G_CALLBACK(begin_print), &printContext); > + g_signal_connect(G_OBJECT(op), "draw-page", G_CALLBACK(draw_page), &printContext); > + g_signal_connect(G_OBJECT(op), "end-print", G_CALLBACK(end_print), &printContext); The G_OBJECT cast is not needed, g_signal_connect takes a gpointer and Xan cleaned up some code to remove the bogus cast and we should not reintroduce . > > - if (error) { > - GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(topLevel), > - GTK_DIALOG_DESTROY_WITH_PARENT, > - GTK_MESSAGE_ERROR, > - GTK_BUTTONS_CLOSE, > - "%s", error->message); > - g_error_free(error); > + if (filename) { > + gtk_print_operation_set_export_filename(op, filename); > + action = GTK_PRINT_OPERATION_ACTION_EXPORT; indention messed up again? > + if (result == GTK_PRINT_OPERATION_RESULT_APPLY && updated_settings) { > + /* If the user printed, and the caller is interested in updated settings, > + * give them back to him > + */ please see the CodingStyle, add a new line... Besides the style issues the patch looks fine and here is the catch. If we want to put that into webkitwebframe.h we will have to discuss the API which maybe adds another week or two delay, if you add the printing to private API I can just r=+ the updated patch. Both things are fine with me, it is up to you. 102994 9 colin 2008-12-19 09:40:02 -0800 OK, I'll look at that; apart from coding style issues, is the patch fine? 102995 10 colin 2008-12-19 09:41:33 -0800 (In reply to comment #9) > OK, I'll look at that; apart from coding style issues, is the patch fine? Forget that, I missed the end of the review :) 102996 11 26145 colin 2008-12-19 09:56:07 -0800 Created attachment 26145 updated patch that fixes CodingStyle Hi, Here's an updated patch that fixes the mentioned style issues. Sorry about indentations, my editor has a tendancy to replace 8 spaces with 1 tab and I usually prefer this coding style, so I let that be :) I doubled checked them this time. About NULL usage in c++, I left them as is because I've noticed lots of NULLs in other cpp files, and I'm not sure 0x0 would be nicer... Feel free to tell me what you'd prefer if you really prefer I don't add NULLs :) I've left the API in webframe.h, I don't mind an extra delay with this patch, and OTOH i'd like to have a defined API - there's another place where I could use it, a future Claws Mail plugin. Thanks! 103000 12 26147 colin 2008-12-19 10:12:07 -0800 Created attachment 26147 updated patch that fixes CodingStyle & Changelog Oops, and add a Changelog entry. 104553 13 colin 2009-01-06 02:44:48 -0800 Hi, I'm pinging back after the holidays... Has someone been able to review my last patch? Thanks! :) 109114 14 marco.barisione 2009-02-10 08:40:27 -0800 You cannot have a different API based on the version of GTK used to compile WebKit and that GTK version could be different from the one used to compile your app. 109271 15 27556 colin 2009-02-11 02:42:00 -0800 Created attachment 27556 Updated patch to have similar API with older GTK This patch is the same as the previous one, adding the same API when built against GTK+2.8 - just replacing undefined types with void in this case. 112179 16 colin 2009-03-04 03:56:22 -0800 (In reply to comment #14) > You cannot have a different API based on the version of GTK used to compile > WebKit and that GTK version could be different from the one used to compile > your app. My latest patch should fix that? 113179 17 gustavo 2009-03-11 07:09:46 -0700 (In reply to comment #16) > (In reply to comment #14) > > You cannot have a different API based on the version of GTK used to compile > > WebKit and that GTK version could be different from the one used to compile > > your app. > > My latest patch should fix that? > I wonder if it is useful at all to support GTK+ versions < 2.10 since we are now requiring such a recent libsoup, for instance. Also, I would prefer having a signal being emitted that lets the application hand in an already prepared GtkPrintOperation, so that the application has good control over the print process, and we would only need a single API method. 113182 18 colin 2009-03-11 07:30:29 -0700 (In reply to comment #17) > (In reply to comment #16) > > (In reply to comment #14) > > > You cannot have a different API based on the version of GTK used to compile > > > WebKit and that GTK version could be different from the one used to compile > > > your app. > > > > My latest patch should fix that? > > > > I wonder if it is useful at all to support GTK+ versions < 2.10 since we are > now requiring such a recent libsoup, for instance. I've been specifically asked for GTK < 2.10 support (or rather API compatilibity). It doesn't add much to the patch. > Also, I would prefer having > a signal being emitted that lets the application hand in an already prepared > GtkPrintOperation, so that the application has good control over the print > process, and we would only need a single API method. The current patch already provides good control in my opinion, and even if it needs two API methods, this way seems more straight-forward for application developers (at least to me) than having to setup a signal callback which will probably require a specific structure to pass GtkPrintSettings and GtkPageSetup back and forth. Printing to file is already possible from within the print dialog, so application developers who only need to print on user's request should be fine with the existing implementation anyway, or with this implemenation using only one API method (webkit_web_frame_print). The goal of this patch is to be able to print to file without user interaction at all. 113219 19 gustavo 2009-03-11 13:59:56 -0700 (In reply to comment #18) > > I wonder if it is useful at all to support GTK+ versions < 2.10 since we are > > now requiring such a recent libsoup, for instance. > > I've been specifically asked for GTK < 2.10 support (or rather API > compatilibity). It doesn't add much to the patch. By who? With what rationale? It's just a small amount of code, indeed, but I am not convinced we need it at all. > The current patch already provides good control in my opinion, and even if it > needs two API methods, this way seems more straight-forward for application > developers (at least to me) than having to setup a signal callback which will > probably require a specific structure to pass GtkPrintSettings and GtkPageSetup > back and forth. I think passing a GtkPrintOperation, really, much in the same way the create-web-view does with WebKitWebView. I am worried that we limit the amount of control the application has regarding the printing process - for instance, displaying progress. > Printing to file is already possible from within the print dialog, so > application developers who only need to print on user's request should be fine > with the existing implementation anyway, or with this implemenation using only > one API method (webkit_web_frame_print). > > The goal of this patch is to be able to print to file without user interaction > at all. Right. The way I understand this, though, ChromeClient::print may be called by javascript code requesting printing, for instance. The current implementation will popup the print dialog if this happens, which may not be what the application intends - it may just as well want to print to a file automatically, with an automatically-generated name, or send the job with a pre-defined configuration to a pre-defined printer. Coupled with my worries about the amount of control the application is able to have regarding the printing process as a whole, I wonder if adding a print-requested signal or something like that, which expects the client to give it an already setup GtkPrintOperation is not the way to go. 113331 20 colin 2009-03-12 01:27:40 -0700 (In reply to comment #19) > > I've been specifically asked for GTK < 2.10 support (or rather API > > compatilibity). It doesn't add much to the patch. > > By who? With what rationale? It's just a small amount of code, indeed, but I am > not convinced we need it at all. See comment #14... > I think passing a GtkPrintOperation, really, much in the same way the > create-web-view does with WebKitWebView. I am worried that we limit the amount > of control the application has regarding the printing process - for instance, > displaying progress. > > > [...] > > Right. The way I understand this, though, ChromeClient::print may be called by > javascript code requesting printing, for instance. The current implementation > will popup the print dialog if this happens, which may not be what the > application intends - it may just as well want to print to a file > automatically, with an automatically-generated name, or send the job with a > pre-defined configuration to a pre-defined printer. > > Coupled with my worries about the amount of control the application is able to > have regarding the printing process as a whole, I wonder if adding a > print-requested signal or something like that, which expects the client to give > it an already setup GtkPrintOperation is not the way to go. It may be good to have an "official" view on this from Webkit's team. Anyway, I lack time to go through complete rewrites of this patch. If the Webkit developers prefer your way of doing, I'll let you write the patch :) 113378 21 gustavo 2009-03-12 06:50:33 -0700 (In reply to comment #20) > (In reply to comment #19) > > > I've been specifically asked for GTK < 2.10 support (or rather API > > > compatilibity). It doesn't add much to the patch. > > > > By who? With what rationale? It's just a small amount of code, indeed, but I am > > not convinced we need it at all. > > See comment #14... OK, what I read there is that we should not be exporting different public APIs depending on GTK+ version. This makes perfect sense, but it doesn't mean we _need_ to support older GTK+ versions. I believe we can focus on gtk > 2.10 from now on, if nobody objects to it for some reason. > It may be good to have an "official" view on this from Webkit's team. > > Anyway, I lack time to go through complete rewrites of this patch. If the > Webkit developers prefer your way of doing, I'll let you write the patch :) Yeah, I think we need to have more API users comment on this, but I'll be glad to write a patch later this month, if need be =). 113417 22 colin 2009-03-12 11:00:20 -0700 (In reply to comment #21) > > See comment #14... > > OK, what I read there is that we should not be exporting different public APIs > depending on GTK+ version. This makes perfect sense, but it doesn't mean we > _need_ to support older GTK+ versions. I believe we can focus on gtk > 2.10 > from now on, if nobody objects to it for some reason. Yes, that's what the patch does (and stock Webkit too): just a g_warning when trying to print on GTK < 2.10. > Yeah, I think we need to have more API users comment on this, but I'll be glad > to write a patch later this month, if need be =). OK, great :) The size of Webkit's source code makes it painful to maintain my patch locally, and handle it cleanly against my package manager, so I'd love to have some way to do what I need upstream - even if it means rewriting 10-50 lines of my own code :) 114788 23 gustavo 2009-03-23 09:37:39 -0700 *** Bug 16493 has been marked as a duplicate of this bug. *** 114789 24 gustavo 2009-03-23 09:39:18 -0700 The bug I marked as duplicate above has a good API suggestion (as well as some discussion regarding goals) IMO. I'll try to implement a patch and post it here. I don't think we will be able to free WebKitFrame from GTK+, though, opinions on that? 114824 25 28859 gustavo 2009-03-23 12:17:55 -0700 Created attachment 28859 proposed printing API Notice that with this patch I am removing support for GTK+ < 2.10. I believe we should start requiring GTK+ >= 2.10 from now on. I will prepare a patch that does that change, too. 114825 26 28860 gustavo 2009-03-23 12:24:54 -0700 Created attachment 28860 proposed API Fixed some small documentation issues. 114834 27 colin 2009-03-23 13:15:17 -0700 Looks good from my point of view... 115723 28 kapouer 2009-03-29 04:23:07 -0700 looks good to me too. In fact i'm using it right now, and it works quite well. I wonder when it will be available upstream ? 115759 29 christian 2009-03-29 13:28:31 -0700 Could you post a patch or source file using the proposed API? I don't really have a good idea of printing and real use cases are the best way to find out what an interface can do. 115783 30 29054 colin 2009-03-30 01:37:18 -0700 Created attachment 29054 API usage example This file shows various uses of the print API implemented in attachment #28860. (It doesn't compile as is, but gives a good idea of what can be done). From my point of view, it's fine and indeed, better than my patch. 115784 31 29055 colin 2009-03-30 01:39:28 -0700 Created attachment 29055 (Fixed) API usage example Same example with a bug fixed in the callback ;) 116018 32 29121 gustavo 2009-03-31 09:33:38 -0700 Created attachment 29121 proposed printing API Reviewed by NOBODY (OOPS!). https://bugs.webkit.org/show_bug.cgi?id=22898 [GTK] need proper API for printing Implement proper printing API, using the GTK+ printing API. * WebCoreSupport/ChromeClientGtk.cpp: (WebKit::ChromeClient::print): * webkit/webkitprivate.h: * webkit/webkitwebframe.cpp: * webkit/webkitwebframe.h: * webkit/webkitwebview.cpp: --- WebKit/gtk/ChangeLog | 16 +++++ WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp | 9 +++- WebKit/gtk/webkit/webkitprivate.h | 3 - WebKit/gtk/webkit/webkitwebframe.cpp | 84 ++++++++++++++++-------- WebKit/gtk/webkit/webkitwebframe.h | 11 +++ WebKit/gtk/webkit/webkitwebview.cpp | 29 +++++++++ 6 files changed, 120 insertions(+), 32 deletions(-) 116019 33 29122 gustavo 2009-03-31 09:33:43 -0700 Created attachment 29122 unit tests for printing Reviewed by NOBODY (OOPS!). https://bugs.webkit.org/show_bug.cgi?id=22898 [GTK] need proper API for printing Added simple printing unit tests. * tests/testwebframe.c: (print_requested_cb): (print_timeout): (test_webkit_web_frame_printing): (main): --- WebKit/gtk/ChangeLog | 15 +++++++ WebKit/gtk/tests/testwebframe.c | 81 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+), 0 deletions(-) 116021 34 29121 gustavo 2009-03-31 09:35:50 -0700 Comment on attachment 29121 proposed printing API This patch has one important change compared to the original one I posted: it makes webkit_web_frame_print take only a WebKitWebFrame, to better acomodate clients which are already messing with that symbol, and adds a webkit_web_frame_print_full to provide the more flexible functionality. 116402 35 29122 zecke 2009-04-02 23:33:45 -0700 Comment on attachment 29122 unit tests for printing > + > + g_assert_cmpint(GPOINTER_TO_INT(g_object_get_data(G_OBJECT(webView), "signal-handled")), ==, TRUE); great!!! > + > + // Does printing directly to a file? > + GError *error = NULL; > + gchar* temporaryFilename = NULL; > + gint fd = g_file_open_tmp ("webkit-testwebframe-XXXXXX", &temporaryFilename, &error); > + close(fd); > + > + // We delete the file, so that we can easily figure out that the > + // file got printed; > + if (error || (g_unlink(temporaryFilename) == -1)) { > + g_critical("Failed to open a temporary file for writing: %s.", error->message); > + g_error_free(error); > + goto cleanup; > + } > + gtk_print_operation_set_export_filename(operation, temporaryFilename); > + result = webkit_web_frame_print_full (webFrame, operation, action, error); This looks like a race. Will GtkPrint just overwrite the export file? 116404 36 29121 zecke 2009-04-02 23:40:03 -0700 Comment on attachment 29121 proposed printing API > - g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL); > + g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), 0); unrelated but okay. > + GtkWidget* topLevel = gtk_widget_get_toplevel(GTK_WIDGET(webkit_web_frame_get_web_view(frame))); > + if (!GTK_WIDGET_TOPLEVEL(topLevel)) > + topLevel = NULL; not consistent with the one above :) > + > + Frame* coreFrame = core(frame); > + if (!coreFrame) > + return GTK_PRINT_OPERATION_RESULT_CANCEL Why this and not GTK_PRINT_OPERATION_RESULT_ERROR? > --- a/WebKit/gtk/webkit/webkitwebframe.h > +++ b/WebKit/gtk/webkit/webkitwebframe.h > @@ -22,6 +22,8 @@ > #define WEBKIT_WEB_FRAME_H > > #include <glib-object.h> > +#include <gtk/gtk.h> oh interesting, the first Gtk+ symbol here :) Yeah, this and the test case look pretty good. 116420 37 gustavo 2009-04-03 06:45:21 -0700 yo! (In reply to comment #35) > (From update of attachment 29122 [review]) > > + > > + // Does printing directly to a file? > > + GError *error = NULL; > > + gchar* temporaryFilename = NULL; > > + gint fd = g_file_open_tmp ("webkit-testwebframe-XXXXXX", &temporaryFilename, &error); > > + close(fd); > > + > > + // We delete the file, so that we can easily figure out that the > > + // file got printed; > > + if (error || (g_unlink(temporaryFilename) == -1)) { > > + g_critical("Failed to open a temporary file for writing: %s.", error->message); > > + g_error_free(error); > > + goto cleanup; > > + } > > > > + gtk_print_operation_set_export_filename(operation, temporaryFilename); > > + result = webkit_web_frame_print_full (webFrame, operation, action, error); > > > This looks like a race. Will GtkPrint just overwrite the export file? > Yes. That doesn't seem to be documented, but from what I could understand from gtk+'s source code, and from my tests, the file is simply overwritten. Why do you think there is a race here? 116422 38 gustavo 2009-04-03 07:01:09 -0700 (In reply to comment #36) > (From update of attachment 29121 [review]) > > > - g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL); > > + g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), 0); > > unrelated but okay. This was actually a mistake. We have agreed to use NULL on API files, so the second one is correct! > > + Frame* coreFrame = core(frame); > > + if (!coreFrame) > > + return GTK_PRINT_OPERATION_RESULT_CANCEL > > Why this and not GTK_PRINT_OPERATION_RESULT_ERROR? My thinking was that the operation has not been attempted, so no error happened. It was cancelled because the frame it was supposed to print does not exist, but on second thought, given that we are in the context of WebKitWebFrame, and that CANCEL also means 'print settings should not be stored', I think ERROR is a better option indeed. > > #include <glib-object.h> > > +#include <gtk/gtk.h> > > oh interesting, the first Gtk+ symbol here :) I guess we could move all this to WebKitWebView, and we would have stuff such as: GtkPrintOperationResult webkit_web_view_print_frame(WebKitWebView* view, WebKitWebFrame* frame, GError* error); GtkPrintOperationResult webkit_web_view_print_frame_full(WebKitWebView* view, WebKitWebFrame* frame, GtkPrintOperation* operation, GtkPrintOperationAction action, GError* error); > Yeah, this and the test case look pretty good. =) 116423 39 29226 gustavo 2009-04-03 07:03:31 -0700 Created attachment 29226 proposed printing API Reviewed by NOBODY (OOPS!). https://bugs.webkit.org/show_bug.cgi?id=22898 [GTK] need proper API for printing Implement proper printing API, using the GTK+ printing API. * WebCoreSupport/ChromeClientGtk.cpp: (WebKit::ChromeClient::print): * webkit/webkitprivate.h: * webkit/webkitwebframe.cpp: * webkit/webkitwebframe.h: * webkit/webkitwebview.cpp: --- WebKit/gtk/ChangeLog | 16 +++++ WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp | 9 +++- WebKit/gtk/webkit/webkitprivate.h | 3 - WebKit/gtk/webkit/webkitwebframe.cpp | 77 +++++++++++++++++++------ WebKit/gtk/webkit/webkitwebframe.h | 11 ++++ WebKit/gtk/webkit/webkitwebview.cpp | 29 +++++++++ 6 files changed, 122 insertions(+), 23 deletions(-) 116424 40 29227 gustavo 2009-04-03 07:03:36 -0700 Created attachment 29227 unit tests for printing Reviewed by NOBODY (OOPS!). https://bugs.webkit.org/show_bug.cgi?id=22898 [GTK] need proper API for printing Added simple printing unit tests. * tests/testwebframe.c: (print_requested_cb): (print_timeout): (test_webkit_web_frame_printing): (main): --- WebKit/gtk/ChangeLog | 15 +++++++ WebKit/gtk/tests/testwebframe.c | 81 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+), 0 deletions(-) 116540 41 29256 gustavo 2009-04-04 12:13:40 -0700 Created attachment 29256 When a download is requested by an ongoing request, use the already provided response to set the suggested filename for the WebKitDownload object, if available. --- WebKit/gtk/ChangeLog | 20 +++++++++++++++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 9 ++++++- WebKit/gtk/webkit/webkitdownload.cpp | 23 +++++++++++++------ WebKit/gtk/webkit/webkitprivate.h | 5 +++- WebKit/gtk/webkit/webkitwebview.cpp | 7 +++++- 5 files changed, 53 insertions(+), 11 deletions(-) 116542 42 29256 gustavo 2009-04-04 12:15:23 -0700 Comment on attachment 29256 When a download is requested by an ongoing request, use the already Ugh... =) bad usage of shell history when using git-send-bugzilla. 116670 43 29288 gustavo 2009-04-06 14:39:09 -0700 Created attachment 29288 proposed printing API Reviewed by NOBODY (OOPS!). https://bugs.webkit.org/show_bug.cgi?id=22898 [GTK] need proper API for printing Implement proper printing API, using the GTK+ printing API. * WebCoreSupport/ChromeClientGtk.cpp: (WebKit::ChromeClient::print): * webkit/webkitprivate.h: * webkit/webkitwebframe.cpp: * webkit/webkitwebframe.h: * webkit/webkitwebview.cpp: --- WebKit/gtk/ChangeLog | 16 ++++++ WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp | 9 +++- WebKit/gtk/webkit/webkitprivate.h | 3 - WebKit/gtk/webkit/webkitwebframe.cpp | 65 ++++++++++++++++++++----- WebKit/gtk/webkit/webkitwebframe.h | 11 ++++ WebKit/gtk/webkit/webkitwebview.cpp | 29 +++++++++++ 6 files changed, 116 insertions(+), 17 deletions(-) 116671 44 29289 gustavo 2009-04-06 14:39:14 -0700 Created attachment 29289 unit tests for printing Reviewed by NOBODY (OOPS!). https://bugs.webkit.org/show_bug.cgi?id=22898 [GTK] need proper API for printing Added simple printing unit tests. * tests/testwebframe.c: (print_requested_cb): (print_timeout): (test_webkit_web_frame_printing): (main): --- WebKit/gtk/ChangeLog | 15 +++++++ WebKit/gtk/tests/testwebframe.c | 86 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 101 insertions(+), 0 deletions(-) 116672 45 29289 gustavo 2009-04-06 14:40:52 -0700 Comment on attachment 29289 unit tests for printing fixing a crasher spotted by chpe 117249 46 29288 zecke 2009-04-11 21:12:15 -0700 Comment on attachment 29288 proposed printing API > + * Emitted when printing is requested by the frame, usually > + * because of a javascript call. While handling this signal you > + * should call webkit_web_frame_print() to do the actual printing. s/While/When/ ??? > + webkit_web_view_signals[PRINT_REQUESTED] = g_signal_new("print-requested", > + G_TYPE_FROM_CLASS(webViewClass), > + (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION), > + 0, > + NULL, > + NULL, > + webkit_marshal_BOOLEAN__OBJECT, > + G_TYPE_BOOLEAN, 1, > + WEBKIT_TYPE_WEB_FRAME); Should we use g_signal_accumulator_true_handled to stop the signal emission? 117270 47 gustavo 2009-04-12 14:49:55 -0700 (In reply to comment #46) > > + * Emitted when printing is requested by the frame, usually > > + * because of a javascript call. While handling this signal you > > + * should call webkit_web_frame_print() to do the actual printing. > > s/While/When/ ??? Yep =) > > + webkit_web_view_signals[PRINT_REQUESTED] = g_signal_new("print-requested", > > + G_TYPE_FROM_CLASS(webViewClass), > > + (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION), > > + 0, > > + NULL, > > + NULL, > > + webkit_marshal_BOOLEAN__OBJECT, > > + G_TYPE_BOOLEAN, 1, > > + WEBKIT_TYPE_WEB_FRAME); > > Should we use g_signal_accumulator_true_handled to stop the signal emission? Yes, indeed. Adding it =). 117273 48 29424 gustavo 2009-04-12 16:04:03 -0700 Created attachment 29424 printing API 117282 49 29424 zecke 2009-04-12 22:16:22 -0700 Comment on attachment 29424 printing API go ahead. 117305 50 gustavo 2009-04-13 09:27:36 -0700 Landed as r42435 and r42436. 117322 51 colin 2009-04-13 11:59:02 -0700 (In reply to comment #50) > Landed as r42435 and r42436. Great, thanks to everybody involved in that :) 26088 2008-12-17 01:37:44 -0800 2008-12-17 13:41:42 -0800 Patch to print frames directly to file webkit_web_frame_print_to_file.patch text/plain 2570 colin SW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAJKHJldmlzaW9uIDM5MzM1KQor KysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC01ODAsNiArNTgwLDQ1IEBACiAgICAgfQogfQogCisKK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9w cmludF90b19maWxlKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgR3RrUHJpbnRTZXR0aW5ncyAqc2V0 dGluZ3MsIEd0a1BhZ2VTZXR1cCAqc2V0dXAsIGNvbnN0IGdjaGFyICpmaWxlbmFtZSkKK3sKKyAg ICBHdGtXaWRnZXQqIHRvcExldmVsID0gZ3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RLX1dJREdF VCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhmcmFtZSkpKTsKKyAgICBpZiAoIUdUS19X SURHRVRfVE9QTEVWRUwodG9wTGV2ZWwpKQorICAgICAgICB0b3BMZXZlbCA9IE5VTEw7CisKKyAg ICBGcmFtZSogY29yZUZyYW1lID0gY29yZShmcmFtZSk7CisgICAgQVNTRVJUKGNvcmVGcmFtZSk7 CisKKyAgICBQcmludENvbnRleHQgcHJpbnRDb250ZXh0KGNvcmVGcmFtZSk7CisKKyAgICBHdGtQ cmludE9wZXJhdGlvbiogb3AgPSBndGtfcHJpbnRfb3BlcmF0aW9uX25ldygpOworICAgIGdfc2ln bmFsX2Nvbm5lY3Qob3AsICJiZWdpbi1wcmludCIsIEdfQ0FMTEJBQ0soYmVnaW5fcHJpbnQpLCAm cHJpbnRDb250ZXh0KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiZHJhdy1wYWdlIiwgR19D QUxMQkFDSyhkcmF3X3BhZ2UpLCAmcHJpbnRDb250ZXh0KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0 KG9wLCAiZW5kLXByaW50IiwgR19DQUxMQkFDSyhlbmRfcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsK KyAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKKworICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0 X2V4cG9ydF9maWxlbmFtZShvcCwgZmlsZW5hbWUpOworICAgIGlmIChwYWdlX3NldHVwKQorICAg ICAgICBndGtfcHJpbnRfb3BlcmF0aW9uX3NldF9kZWZhdWx0X3BhZ2Vfc2V0dXAob3AsIHBhZ2Vf c2V0dXApOworICAgIGlmIChzZXR0aW5ncykKKyAgICAgICAgZ3RrX3ByaW50X29wZXJhdGlvbl9z ZXRfcHJpbnRfc2V0dGluZ3Mob3AsIHNldHRpbmdzKTsKKyAgICBndGtfcHJpbnRfb3BlcmF0aW9u X3J1bihvcCwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fRVhQT1JULCBHVEtfV0lORE9XKHRv cExldmVsKSwgJmVycm9yKTsKKyAgICBnX29iamVjdF91bnJlZihvcCk7CisKKyAgICBpZiAoZXJy b3IpIHsKKyAgICAgICAgR3RrV2lkZ2V0KiBkaWFsb2cgPSBndGtfbWVzc2FnZV9kaWFsb2dfbmV3 KEdUS19XSU5ET1codG9wTGV2ZWwpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgR1RLX0RJQUxPR19ERVNUUk9ZX1dJVEhfUEFSRU5ULAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX01FU1NBR0Vf RVJST1IsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBHVEtfQlVUVE9OU19DTE9TRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICIlcyIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgZ19lcnJvcl9m cmVlKGVycm9yKTsKKworICAgICAgICBnX3NpZ25hbF9jb25uZWN0KGRpYWxvZywgInJlc3BvbnNl IiwgR19DQUxMQkFDSyhndGtfd2lkZ2V0X2Rlc3Ryb3kpLCBOVUxMKTsKKyAgICAgICAgZ3RrX3dp ZGdldF9zaG93KGRpYWxvZyk7CisgICAgfQorfQorCiAjZWxzZQogCiB2b2lkIHdlYmtpdF93ZWJf ZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJhbWUqKQpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuaAkocmV2aXNpb24gMzkzMzUpCisrKyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0MSw2ICsxNDEsMTEgQEAKICAgICBXRUJLSVRfQVBJIHZv aWQKICAgICB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50IChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwog CisjaWYgR1RLX0NIRUNLX1ZFUlNJT04oMiwxMCwwKQorICAgIFdFQktJVF9BUEkgdm9pZAorICAg IHdlYmtpdF93ZWJfZnJhbWVfcHJpbnRfdG9fZmlsZSAoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBH dGtQcmludFNldHRpbmdzICpzZXR0aW5ncywgR3RrUGFnZVNldHVwICpwYWdlX3NldHVwLCBjb25z dCBnY2hhciAqZmlsZW5hbWUpOworI2VuZGlmCisKICAgICBXRUJLSVRfQVBJIGdjaGFyKgogICAg IHdlYmtpdF93ZWJfZnJhbWVfZHVtcF9yZW5kZXJfdHJlZSAoV2ViS2l0V2ViRnJhbWUqIGZyYW1l KTsKIAo= 26101 2008-12-17 13:41:42 -0800 2008-12-18 01:02:42 -0800 Fixed patch patch.2 text/plain 2575 colin SW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAJKHJldmlzaW9uIDM5MzM1KQor KysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC01ODAsNiArNTgwLDQ1IEBACiAgICAgfQogfQogCisKK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9w cmludF90b19maWxlKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgR3RrUHJpbnRTZXR0aW5ncyAqc2V0 dGluZ3MsIEd0a1BhZ2VTZXR1cCAqcGFnZV9zZXR1cCwgY29uc3QgZ2NoYXIgKmZpbGVuYW1lKQor eworICAgIEd0a1dpZGdldCogdG9wTGV2ZWwgPSBndGtfd2lkZ2V0X2dldF90b3BsZXZlbChHVEtf V0lER0VUKHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3dlYl92aWV3KGZyYW1lKSkpOworICAgIGlmICgh R1RLX1dJREdFVF9UT1BMRVZFTCh0b3BMZXZlbCkpCisgICAgICAgIHRvcExldmVsID0gTlVMTDsK KworICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKKyAgICBBU1NFUlQoY29yZUZy YW1lKTsKKworICAgIFByaW50Q29udGV4dCBwcmludENvbnRleHQoY29yZUZyYW1lKTsKKworICAg IEd0a1ByaW50T3BlcmF0aW9uKiBvcCA9IGd0a19wcmludF9vcGVyYXRpb25fbmV3KCk7CisgICAg Z19zaWduYWxfY29ubmVjdChvcCwgImJlZ2luLXByaW50IiwgR19DQUxMQkFDSyhiZWdpbl9wcmlu dCksICZwcmludENvbnRleHQpOworICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJkcmF3LXBhZ2Ui LCBHX0NBTExCQUNLKGRyYXdfcGFnZSksICZwcmludENvbnRleHQpOworICAgIGdfc2lnbmFsX2Nv bm5lY3Qob3AsICJlbmQtcHJpbnQiLCBHX0NBTExCQUNLKGVuZF9wcmludCksICZwcmludENvbnRl eHQpOworICAgIEdFcnJvciAqZXJyb3IgPSBOVUxMOworCisgICAgZ3RrX3ByaW50X29wZXJhdGlv bl9zZXRfZXhwb3J0X2ZpbGVuYW1lKG9wLCBmaWxlbmFtZSk7CisgICAgaWYgKHBhZ2Vfc2V0dXAp CisgICAgICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X2RlZmF1bHRfcGFnZV9zZXR1cChvcCwg cGFnZV9zZXR1cCk7CisgICAgaWYgKHNldHRpbmdzKQorICAgICAgICBndGtfcHJpbnRfb3BlcmF0 aW9uX3NldF9wcmludF9zZXR0aW5ncyhvcCwgc2V0dGluZ3MpOworICAgIGd0a19wcmludF9vcGVy YXRpb25fcnVuKG9wLCBHVEtfUFJJTlRfT1BFUkFUSU9OX0FDVElPTl9FWFBPUlQsIEdUS19XSU5E T1codG9wTGV2ZWwpLCAmZXJyb3IpOworICAgIGdfb2JqZWN0X3VucmVmKG9wKTsKKworICAgIGlm IChlcnJvcikgeworICAgICAgICBHdGtXaWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxv Z19uZXcoR1RLX1dJTkRPVyh0b3BMZXZlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElBTE9HX0RFU1RST1lfV0lUSF9QQVJFTlQsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfTUVT U0FHRV9FUlJPUiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEdUS19CVVRUT05TX0NMT1NFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIiVzIiwgZXJyb3ItPm1lc3NhZ2UpOworICAgICAgICBnX2Vy cm9yX2ZyZWUoZXJyb3IpOworCisgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QoZGlhbG9nLCAicmVz cG9uc2UiLCBHX0NBTExCQUNLKGd0a193aWRnZXRfZGVzdHJveSksIE5VTEwpOworICAgICAgICBn dGtfd2lkZ2V0X3Nob3coZGlhbG9nKTsKKyAgICB9Cit9CisKICNlbHNlCiAKIHZvaWQgd2Via2l0 X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSopCkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5oCShyZXZpc2lvbiAzOTMzNSkKKysrIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtMTQxLDYgKzE0MSwxMSBAQAogICAgIFdFQktJVF9B UEkgdm9pZAogICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQgKFdlYktpdFdlYkZyYW1lKiBmcmFt ZSk7CiAKKyNpZiBHVEtfQ0hFQ0tfVkVSU0lPTigyLDEwLDApCisgICAgV0VCS0lUX0FQSSB2b2lk CisgICAgd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19maWxlIChXZWJLaXRXZWJGcmFtZSogZnJh bWUsIEd0a1ByaW50U2V0dGluZ3MgKnNldHRpbmdzLCBHdGtQYWdlU2V0dXAgKnBhZ2Vfc2V0dXAs IGNvbnN0IGdjaGFyICpmaWxlbmFtZSk7CisjZW5kaWYKKwogICAgIFdFQktJVF9BUEkgZ2NoYXIq CiAgICAgd2Via2l0X3dlYl9mcmFtZV9kdW1wX3JlbmRlcl90cmVlIChXZWJLaXRXZWJGcmFtZSog ZnJhbWUpOwogCg== 26119 2008-12-18 01:02:42 -0800 2008-12-19 09:56:07 -0800 Patch that completes and makes GtkPrint API public webkit_print.patch text/plain 7646 colin SW5kZXg6IFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAJ KHJldmlzaW9uIDM5MzM1KQorKysgV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGll bnRHdGsuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zODUsNyArMzg1LDIyIEBACiAKIHZvaWQgQ2hy b21lQ2xpZW50OjpwcmludChGcmFtZSogZnJhbWUpCiB7Ci0gICAgd2Via2l0X3dlYl9mcmFtZV9w cmludChraXQoZnJhbWUpKTsKKyAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKKyAgICB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50KGtpdChmcmFtZSksIE5VTEwsIE5VTEwsICZlcnJvciwgTlVMTCk7Cisg ICAgaWYgKGVycm9yKSB7CisJR3RrV2lkZ2V0KiB0b3BMZXZlbCA9IGd0a193aWRnZXRfZ2V0X3Rv cGxldmVsKEdUS19XSURHRVQod2Via2l0X3dlYl9mcmFtZV9nZXRfd2ViX3ZpZXcoa2l0KGZyYW1l KSkpKTsKKwlpZiAoIUdUS19XSURHRVRfVE9QTEVWRUwodG9wTGV2ZWwpKQorICAgICAgICAgICAg dG9wTGV2ZWwgPSBOVUxMOworICAgICAgICBHdGtXaWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdl X2RpYWxvZ19uZXcoR1RLX1dJTkRPVyh0b3BMZXZlbCksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElBTE9HX0RFU1RST1lfV0lUSF9QQVJF TlQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBH VEtfTUVTU0FHRV9FUlJPUiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NFLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIiVzIiwgZXJyb3ItPm1lc3NhZ2UpOworICAgICAg ICBnX2Vycm9yX2ZyZWUoZXJyb3IpOworCisgICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QoZGlhbG9n LCAicmVzcG9uc2UiLCBHX0NBTExCQUNLKGd0a193aWRnZXRfZGVzdHJveSksIE5VTEwpOworICAg ICAgICBndGtfd2lkZ2V0X3Nob3coZGlhbG9nKTsKKyAgICB9CiB9CiAKIHZvaWQgQ2hyb21lQ2xp ZW50OjpleGNlZWRlZERhdGFiYXNlUXVvdGEoRnJhbWUqIGZyYW1lLCBjb25zdCBTdHJpbmcmKQpJ bmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAkocmV2aXNpb24gMzkzMzUpCisr KyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTUsNiArNSw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQ2hyaXN0aWFuIER5d2FuIDxjaHJp c3RpYW5AaW1lbmRpby5jb20+CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQ29sbGFib3JhIEx0ZC4K ICAqIENvcHlyaWdodCAoQykgMjAwOCBOdWFudGkgTHRkLgorICogQ29weXJpZ2h0IChDKSAyMDA4 IENvbGluIExlcm95IDxjb2xpbkBjb2xpbm8ubmV0Pi4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkg aXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAt NTQ4LDcgKzU0OSw3IEBACiAgICAgcHJpbnRDb250ZXh0LT5lbmQoKTsKIH0KIAotdm9pZCB3ZWJr aXRfd2ViX2ZyYW1lX3ByaW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKK3N0YXRpYyB2b2lkIGZy YW1lX3ByaW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGlu Z3MsIEd0a1BhZ2VTZXR1cCAqcGFnZV9zZXR1cCwgY29uc3QgZ2NoYXIgKmZpbGVuYW1lLCBHRXJy b3IgKiplcnJvciwgR3RrUHJpbnRTZXR0aW5ncyAqKnVwZGF0ZWRfc2V0dGluZ3MpCiB7CiAgICAg R3RrV2lkZ2V0KiB0b3BMZXZlbCA9IGd0a193aWRnZXRfZ2V0X3RvcGxldmVsKEdUS19XSURHRVQo d2Via2l0X3dlYl9mcmFtZV9nZXRfd2ViX3ZpZXcoZnJhbWUpKSk7CiAgICAgaWYgKCFHVEtfV0lE R0VUX1RPUExFVkVMKHRvcExldmVsKSkKQEAgLTU1OCwzMyArNTU5LDY2IEBACiAgICAgQVNTRVJU KGNvcmVGcmFtZSk7CiAKICAgICBQcmludENvbnRleHQgcHJpbnRDb250ZXh0KGNvcmVGcmFtZSk7 CisgICAgR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gYWN0aW9uOwogCiAgICAgR3RrUHJpbnRPcGVy YXRpb24qIG9wID0gZ3RrX3ByaW50X29wZXJhdGlvbl9uZXcoKTsKLSAgICBnX3NpZ25hbF9jb25u ZWN0KG9wLCAiYmVnaW4tcHJpbnQiLCBHX0NBTExCQUNLKGJlZ2luX3ByaW50KSwgJnByaW50Q29u dGV4dCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChvcCwgImRyYXctcGFnZSIsIEdfQ0FMTEJBQ0so ZHJhd19wYWdlKSwgJnByaW50Q29udGV4dCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChvcCwgImVu ZC1wcmludCIsIEdfQ0FMTEJBQ0soZW5kX3ByaW50KSwgJnByaW50Q29udGV4dCk7Ci0gICAgR0Vy cm9yICplcnJvciA9IE5VTEw7Ci0gICAgZ3RrX3ByaW50X29wZXJhdGlvbl9ydW4ob3AsIEdUS19Q UklOVF9PUEVSQVRJT05fQUNUSU9OX1BSSU5UX0RJQUxPRywgR1RLX1dJTkRPVyh0b3BMZXZlbCks ICZlcnJvcik7Ci0gICAgZ19vYmplY3RfdW5yZWYob3ApOworICAgIGdfc2lnbmFsX2Nvbm5lY3Qo R19PQkpFQ1Qob3ApLCAiYmVnaW4tcHJpbnQiLCBHX0NBTExCQUNLKGJlZ2luX3ByaW50KSwgJnBy aW50Q29udGV4dCk7CisgICAgZ19zaWduYWxfY29ubmVjdChHX09CSkVDVChvcCksICJkcmF3LXBh Z2UiLCBHX0NBTExCQUNLKGRyYXdfcGFnZSksICZwcmludENvbnRleHQpOworICAgIGdfc2lnbmFs X2Nvbm5lY3QoR19PQkpFQ1Qob3ApLCAiZW5kLXByaW50IiwgR19DQUxMQkFDSyhlbmRfcHJpbnQp LCAmcHJpbnRDb250ZXh0KTsKIAotICAgIGlmIChlcnJvcikgewotICAgICAgICBHdGtXaWRnZXQq IGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxvZ19uZXcoR1RLX1dJTkRPVyh0b3BMZXZlbCksCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElB TE9HX0RFU1RST1lfV0lUSF9QQVJFTlQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBHVEtfTUVTU0FHRV9FUlJPUiwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NFLAotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiVzIiwgZXJy b3ItPm1lc3NhZ2UpOwotICAgICAgICBnX2Vycm9yX2ZyZWUoZXJyb3IpOworICAgIGlmIChmaWxl bmFtZSkgeworICAgICAgICBndGtfcHJpbnRfb3BlcmF0aW9uX3NldF9leHBvcnRfZmlsZW5hbWUo b3AsIGZpbGVuYW1lKTsKKwlhY3Rpb24gPSBHVEtfUFJJTlRfT1BFUkFUSU9OX0FDVElPTl9FWFBP UlQ7CisgICAgfSBlbHNlIHsKKyAgICAgICAgYWN0aW9uID0gR1RLX1BSSU5UX09QRVJBVElPTl9B Q1RJT05fUFJJTlRfRElBTE9HOworICAgIH0KIAotICAgICAgICBnX3NpZ25hbF9jb25uZWN0KGRp YWxvZywgInJlc3BvbnNlIiwgR19DQUxMQkFDSyhndGtfd2lkZ2V0X2Rlc3Ryb3kpLCBOVUxMKTsK LSAgICAgICAgZ3RrX3dpZGdldF9zaG93KGRpYWxvZyk7CisgICAgaWYgKHNldHRpbmdzKQorICAg ICAgICBndGtfcHJpbnRfb3BlcmF0aW9uX3NldF9wcmludF9zZXR0aW5ncyhvcCwgc2V0dGluZ3Mp OworICAgIGlmIChwYWdlX3NldHVwKQorICAgICAgICBndGtfcHJpbnRfb3BlcmF0aW9uX3NldF9k ZWZhdWx0X3BhZ2Vfc2V0dXAob3AsIHBhZ2Vfc2V0dXApOworCisKKyAgICBHdGtQcmludE9wZXJh dGlvblJlc3VsdCByZXN1bHQgPSBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bihvcCwgYWN0aW9uLCBH VEtfV0lORE9XKHRvcExldmVsKSwgZXJyb3IpOworICAgIGlmIChyZXN1bHQgPT0gR1RLX1BSSU5U X09QRVJBVElPTl9SRVNVTFRfQVBQTFkgJiYgdXBkYXRlZF9zZXR0aW5ncykgeworICAgICAgICAv KiBJZiB0aGUgdXNlciBwcmludGVkLCBhbmQgdGhlIGNhbGxlciBpcyBpbnRlcmVzdGVkIGluIHVw ZGF0ZWQgc2V0dGluZ3MsIAorICAgICAgICAgKiBnaXZlIHRoZW0gYmFjayB0byBoaW0gCisgICAg ICAgICAqLworICAgICAgICAqdXBkYXRlZF9zZXR0aW5ncyA9IChHdGtQcmludFNldHRpbmdzICop Z19vYmplY3RfcmVmIChndGtfcHJpbnRfb3BlcmF0aW9uX2dldF9wcmludF9zZXR0aW5ncyAob3Ap KTsKICAgICB9CisKKyAgICBnX29iamVjdF91bnJlZihvcCk7CisKIH0KIAotI2Vsc2UKKy8qKgor ICogd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19maWxlOgorICogQGZyYW1lOiBhICNXZWJLaXRX ZWJGcmFtZQorICogQHNldHRpbmdzOiAjR3RrUHJpbnRTZXR0aW5ncyB0byBhcHBseSwgb3IgTlVM TCB0byB1c2UgZGVmYXVsdHMKKyAqIEBwYWdlX3NldHVwOiAjR3RrUGFnZVNldHVwIHRvIHVzZSwg b3IgTlVMTCB0byB1c2UgZGVmYXVsdHMKKyAqIEBmaWxlbmFtZTogb3V0cHV0IGZpbGVuYW1lIHRv IHN0b3JlIHRoZSBwcmludCByZXN1bHQKKyAqIEBlcnJvcjogI0dFcnJvciB0byBzdG9yZSBhIHBv c3NpYmxlIGVycm9yIG1lc3NhZ2UKKyAqCisgKiBQcmludHMgdGhlIGdpdmVuIGZyYW1lIHRvIGZp bGUuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19maWxlKFdlYktpdFdlYkZy YW1lKiBmcmFtZSwgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIEd0a1BhZ2VTZXR1cCAqcGFn ZV9zZXR1cCwgY29uc3QgZ2NoYXIgKmZpbGVuYW1lLCBHRXJyb3IgKiplcnJvcikKK3sKKyAgICBm cmFtZV9wcmludChmcmFtZSwgc2V0dGluZ3MsIHBhZ2Vfc2V0dXAsIGZpbGVuYW1lLCBlcnJvciwg TlVMTCk7Cit9CiAKLXZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSop CisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6CisgKiBAZnJhbWU6IGEgI1dlYktpdFdl YkZyYW1lCisgKiBAc2V0dGluZ3M6ICNHdGtQcmludFNldHRpbmdzIHRvIGFwcGx5LCBvciBOVUxM IHRvIHVzZSBkZWZhdWx0cworICogQHBhZ2Vfc2V0dXA6ICNHdGtQYWdlU2V0dXAgdG8gdXNlLCBv ciBOVUxMIHRvIHVzZSBkZWZhdWx0cworICogQGVycm9yOiAjR0Vycm9yIHRvIHN0b3JlIGEgcG9z c2libGUgZXJyb3IgbWVzc2FnZQorICogQHVwZGF0ZWRfc2V0dGluZ3M6IG5ldyAjR3RrUHJpbnRT ZXR0aW5ncyByZWZsZWN0aW5nIHRoZSBwb3NzaWJsZSBjaGFuZ2VzIGRvbmUgaW4gdGhlIGRpYWxv Zy4KKyAqCisgKiBQcmludHMgdGhlIGdpdmVuIGZyYW1lIGFmdGVyIGRpc3BsYXlpbmcgdGhlIEdU SyBwcmludGluZyBkaWFsb2cuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJL aXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50U2V0dGluZ3MgKnNldHRpbmdzLCBHdGtQYWdlU2V0 dXAgKnBhZ2Vfc2V0dXAsIEdFcnJvciAqKmVycm9yLCBHdGtQcmludFNldHRpbmdzICoqdXBkYXRl ZF9zZXR0aW5ncykKIHsKLSAgICBnX3dhcm5pbmcoIlByaW50aW5nIHN1cHBvcnQgaXMgbm90IGF2 YWlsYWJsZSBpbiBvbGRlciB2ZXJzaW9ucyBvZiBHVEsrIik7CisgICAgZnJhbWVfcHJpbnQoZnJh bWUsIHNldHRpbmdzLCBwYWdlX3NldHVwLCBOVUxMLCBlcnJvciwgdXBkYXRlZF9zZXR0aW5ncyk7 CiB9CiAKICNlbmRpZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oCShyZXZpc2lv biAzOTMzNSkKKysrIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgJKHdvcmtpbmcg Y29weSkKQEAgLTIyLDYgKzIyLDggQEAKICNkZWZpbmUgV0VCS0lUX1dFQl9GUkFNRV9ICiAKICNp bmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPGd0ay9ndGsuaD4KKwogI2luY2x1ZGUg PEphdmFTY3JpcHRDb3JlL0pTQmFzZS5oPgogCiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRlZmlu ZXMuaD4KQEAgLTk3LDYgKzk5LDIyIEBACiBXRUJLSVRfQVBJIEpTR2xvYmFsQ29udGV4dFJlZgog d2Via2l0X3dlYl9mcmFtZV9nZXRfZ2xvYmFsX2NvbnRleHQgKFdlYktpdFdlYkZyYW1lICAgICAg ICpmcmFtZSk7CiAKKyNpZiBHVEtfQ0hFQ0tfVkVSU0lPTigyLDEwLDApCitXRUJLSVRfQVBJIHZv aWQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnQgICAgICAgICAgICAgIChXZWJLaXRXZWJGcmFtZSAg ICpmcmFtZSwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR3RrUHJpbnRT ZXR0aW5ncyAqc2V0dGluZ3MsIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEd0a1BhZ2VTZXR1cCAgICAgKnNldHVwLCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBHRXJyb3IgICAgICAgICAgICoqZXJyb3IsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR3RrUHJpbnRTZXR0aW5ncyAqKnVwZGF0ZWRfc2V0dGluZ3MpOworCitX RUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnRfdG9fZmlsZSAgICAgIChXZWJL aXRXZWJGcmFtZSAgICpmcmFtZSwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEd0a1BhZ2VTZXR1cCAgICAgKnNldHVwLCAKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAgICAgICpmaWxlbmFtZSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHRXJyb3IgICAgICAgICAgICoqZXJyb3IpOwor I2VuZGlmCisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHBy aXZhdGUuaAkocmV2aXNpb24gMzkzMzUpCisrKyBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEzOCw5ICsxMzgsNiBAQAogICAgIFdFQktJVF9BUEkg Z2NoYXIqCiAgICAgd2Via2l0X3dlYl9mcmFtZV9nZXRfaW5uZXJfdGV4dCAoV2ViS2l0V2ViRnJh bWUqIGZyYW1lKTsKIAotICAgIFdFQktJVF9BUEkgdm9pZAotICAgIHdlYmtpdF93ZWJfZnJhbWVf cHJpbnQgKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7Ci0KICAgICBXRUJLSVRfQVBJIGdjaGFyKgog ICAgIHdlYmtpdF93ZWJfZnJhbWVfZHVtcF9yZW5kZXJfdHJlZSAoV2ViS2l0V2ViRnJhbWUqIGZy YW1lKTsKIAo= 26145 2008-12-19 09:56:07 -0800 2008-12-19 10:12:07 -0800 updated patch that fixes CodingStyle webkit_print.2.patch text/plain 7319 colin SW5kZXg6IFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAJ KHJldmlzaW9uIDM5MzM1KQorKysgV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGll bnRHdGsuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zODUsNyArMzg1LDI2IEBACiAKIHZvaWQgQ2hy b21lQ2xpZW50OjpwcmludChGcmFtZSogZnJhbWUpCiB7Ci0gICAgd2Via2l0X3dlYl9mcmFtZV9w cmludChraXQoZnJhbWUpKTsKKyAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKKyAgICB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50KGtpdChmcmFtZSksIE5VTEwsIE5VTEwsICZlcnJvciwgTlVMTCk7Cisg ICAgaWYgKCFlcnJvcikgeworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR3RrV2lkZ2V0 KiB0b3BMZXZlbCA9IGd0a193aWRnZXRfZ2V0X3RvcGxldmVsKEdUS19XSURHRVQod2Via2l0X3dl Yl9mcmFtZV9nZXRfd2ViX3ZpZXcoa2l0KGZyYW1lKSkpKTsKKyAgICBpZiAoIUdUS19XSURHRVRf VE9QTEVWRUwodG9wTGV2ZWwpKSB7CisgICAgICAgIHRvcExldmVsID0gTlVMTDsKKyAgICB9CisK KyAgICBHdGtXaWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxvZ19uZXcoR1RLX1dJTkRP Vyh0b3BMZXZlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElBTE9HX0RFU1RS T1lfV0lUSF9QQVJFTlQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfTUVTU0FHRV9F UlJPUiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NFLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgIiVzIiwgZXJyb3ItPm1lc3NhZ2UpOworICAgIGdfZXJy b3JfZnJlZShlcnJvcik7CisKKyAgICBnX3NpZ25hbF9jb25uZWN0KGRpYWxvZywgInJlc3BvbnNl IiwgR19DQUxMQkFDSyhndGtfd2lkZ2V0X2Rlc3Ryb3kpLCBOVUxMKTsKKyAgICBndGtfd2lkZ2V0 X3Nob3coZGlhbG9nKTsKIH0KIAogdm9pZCBDaHJvbWVDbGllbnQ6OmV4Y2VlZGVkRGF0YWJhc2VR dW90YShGcmFtZSogZnJhbWUsIGNvbnN0IFN0cmluZyYpCkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJmcmFtZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViZnJhbWUuY3BwCShyZXZpc2lvbiAzOTMzNSkKKysrIFdlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYmZyYW1lLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNSw2ICs1LDcgQEAKICAqIENvcHly aWdodCAoQykgMjAwOCBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlvLmNvbT4KICAq IENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgogICogQ29weXJpZ2h0IChDKSAyMDA4 IE51YW50aSBMdGQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggQ29saW4gTGVyb3kgPGNvbGluQGNv bGluby5uZXQ+LgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC01NDgsNyArNTQ5LDcgQEAKICAgICBw cmludENvbnRleHQtPmVuZCgpOwogfQogCi12b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2Vi S2l0V2ViRnJhbWUqIGZyYW1lKQorc3RhdGljIHZvaWQgZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJh bWUqIGZyYW1lLCBHdGtQcmludFNldHRpbmdzICpzZXR0aW5ncywgR3RrUGFnZVNldHVwICpwYWdl X3NldHVwLCBjb25zdCBnY2hhciAqZmlsZW5hbWUsIEdFcnJvciAqKmVycm9yLCBHdGtQcmludFNl dHRpbmdzICoqdXBkYXRlZF9zZXR0aW5ncykKIHsKICAgICBHdGtXaWRnZXQqIHRvcExldmVsID0g Z3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RLX1dJREdFVCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93 ZWJfdmlldyhmcmFtZSkpKTsKICAgICBpZiAoIUdUS19XSURHRVRfVE9QTEVWRUwodG9wTGV2ZWwp KQpAQCAtNTU4LDMzICs1NTksNjcgQEAKICAgICBBU1NFUlQoY29yZUZyYW1lKTsKIAogICAgIFBy aW50Q29udGV4dCBwcmludENvbnRleHQoY29yZUZyYW1lKTsKKyAgICBHdGtQcmludE9wZXJhdGlv bkFjdGlvbiBhY3Rpb247CiAKICAgICBHdGtQcmludE9wZXJhdGlvbiogb3AgPSBndGtfcHJpbnRf b3BlcmF0aW9uX25ldygpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJiZWdpbi1wcmludCIs IEdfQ0FMTEJBQ0soYmVnaW5fcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsKICAgICBnX3NpZ25hbF9j b25uZWN0KG9wLCAiZHJhdy1wYWdlIiwgR19DQUxMQkFDSyhkcmF3X3BhZ2UpLCAmcHJpbnRDb250 ZXh0KTsKICAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiZW5kLXByaW50IiwgR19DQUxMQkFDSyhl bmRfcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsKLSAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKLSAg ICBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bihvcCwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05f UFJJTlRfRElBTE9HLCBHVEtfV0lORE9XKHRvcExldmVsKSwgJmVycm9yKTsKLSAgICBnX29iamVj dF91bnJlZihvcCk7CiAKLSAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgR3RrV2lkZ2V0KiBkaWFs b2cgPSBndGtfbWVzc2FnZV9kaWFsb2dfbmV3KEdUS19XSU5ET1codG9wTGV2ZWwpLAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX0RJQUxPR19E RVNUUk9ZX1dJVEhfUEFSRU5ULAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR1RLX01FU1NBR0VfRVJST1IsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfQlVUVE9OU19DTE9TRSwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICIlcyIsIGVycm9yLT5t ZXNzYWdlKTsKLSAgICAgICAgZ19lcnJvcl9mcmVlKGVycm9yKTsKKyAgICBpZiAoZmlsZW5hbWUp IHsKKyAgICAgICAgZ3RrX3ByaW50X29wZXJhdGlvbl9zZXRfZXhwb3J0X2ZpbGVuYW1lKG9wLCBm aWxlbmFtZSk7CisgICAgICAgIGFjdGlvbiA9IEdUS19QUklOVF9PUEVSQVRJT05fQUNUSU9OX0VY UE9SVDsKKyAgICB9IGVsc2UgeworICAgICAgICBhY3Rpb24gPSBHVEtfUFJJTlRfT1BFUkFUSU9O X0FDVElPTl9QUklOVF9ESUFMT0c7CisgICAgfQogCi0gICAgICAgIGdfc2lnbmFsX2Nvbm5lY3Qo ZGlhbG9nLCAicmVzcG9uc2UiLCBHX0NBTExCQUNLKGd0a193aWRnZXRfZGVzdHJveSksIE5VTEwp OwotICAgICAgICBndGtfd2lkZ2V0X3Nob3coZGlhbG9nKTsKKyAgICBpZiAoc2V0dGluZ3MpCisg ICAgICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X3ByaW50X3NldHRpbmdzKG9wLCBzZXR0aW5n cyk7CisgICAgaWYgKHBhZ2Vfc2V0dXApCisgICAgICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0 X2RlZmF1bHRfcGFnZV9zZXR1cChvcCwgcGFnZV9zZXR1cCk7CisKKworICAgIEd0a1ByaW50T3Bl cmF0aW9uUmVzdWx0IHJlc3VsdCA9IGd0a19wcmludF9vcGVyYXRpb25fcnVuKG9wLCBhY3Rpb24s IEdUS19XSU5ET1codG9wTGV2ZWwpLCBlcnJvcik7CisgICAgaWYgKHJlc3VsdCA9PSBHVEtfUFJJ TlRfT1BFUkFUSU9OX1JFU1VMVF9BUFBMWSAmJiB1cGRhdGVkX3NldHRpbmdzKSB7CisgICAgICAg IC8qIAorICAgICAgICAgKiBJZiB0aGUgdXNlciBwcmludGVkLCBhbmQgdGhlIGNhbGxlciBpcyBp bnRlcmVzdGVkIGluIHVwZGF0ZWQgc2V0dGluZ3MsIAorICAgICAgICAgKiBnaXZlIHRoZW0gYmFj ayB0byBoaW0gCisgICAgICAgICAqLworICAgICAgICAqdXBkYXRlZF9zZXR0aW5ncyA9IChHdGtQ cmludFNldHRpbmdzICopZ19vYmplY3RfcmVmIChndGtfcHJpbnRfb3BlcmF0aW9uX2dldF9wcmlu dF9zZXR0aW5ncyAob3ApKTsKICAgICB9CisKKyAgICBnX29iamVjdF91bnJlZihvcCk7CisKIH0K IAotI2Vsc2UKKy8qKgorICogd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19maWxlOgorICogQGZy YW1lOiBhICNXZWJLaXRXZWJGcmFtZQorICogQHNldHRpbmdzOiAjR3RrUHJpbnRTZXR0aW5ncyB0 byBhcHBseSwgb3IgTlVMTCB0byB1c2UgZGVmYXVsdHMKKyAqIEBwYWdlX3NldHVwOiAjR3RrUGFn ZVNldHVwIHRvIHVzZSwgb3IgTlVMTCB0byB1c2UgZGVmYXVsdHMKKyAqIEBmaWxlbmFtZTogb3V0 cHV0IGZpbGVuYW1lIHRvIHN0b3JlIHRoZSBwcmludCByZXN1bHQKKyAqIEBlcnJvcjogI0dFcnJv ciB0byBzdG9yZSBhIHBvc3NpYmxlIGVycm9yIG1lc3NhZ2UKKyAqCisgKiBQcmludHMgdGhlIGdp dmVuIGZyYW1lIHRvIGZpbGUuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19m aWxlKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIEd0 a1BhZ2VTZXR1cCAqcGFnZV9zZXR1cCwgY29uc3QgZ2NoYXIgKmZpbGVuYW1lLCBHRXJyb3IgKipl cnJvcikKK3sKKyAgICBmcmFtZV9wcmludChmcmFtZSwgc2V0dGluZ3MsIHBhZ2Vfc2V0dXAsIGZp bGVuYW1lLCBlcnJvciwgTlVMTCk7Cit9CiAKLXZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChX ZWJLaXRXZWJGcmFtZSopCisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6CisgKiBAZnJh bWU6IGEgI1dlYktpdFdlYkZyYW1lCisgKiBAc2V0dGluZ3M6ICNHdGtQcmludFNldHRpbmdzIHRv IGFwcGx5LCBvciBOVUxMIHRvIHVzZSBkZWZhdWx0cworICogQHBhZ2Vfc2V0dXA6ICNHdGtQYWdl U2V0dXAgdG8gdXNlLCBvciBOVUxMIHRvIHVzZSBkZWZhdWx0cworICogQGVycm9yOiAjR0Vycm9y IHRvIHN0b3JlIGEgcG9zc2libGUgZXJyb3IgbWVzc2FnZQorICogQHVwZGF0ZWRfc2V0dGluZ3M6 IG5ldyAjR3RrUHJpbnRTZXR0aW5ncyByZWZsZWN0aW5nIHRoZSBwb3NzaWJsZSBjaGFuZ2VzIGRv bmUgaW4gdGhlIGRpYWxvZy4KKyAqCisgKiBQcmludHMgdGhlIGdpdmVuIGZyYW1lIGFmdGVyIGRp c3BsYXlpbmcgdGhlIEdUSyBwcmludGluZyBkaWFsb2cuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9m cmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50U2V0dGluZ3MgKnNldHRp bmdzLCBHdGtQYWdlU2V0dXAgKnBhZ2Vfc2V0dXAsIEdFcnJvciAqKmVycm9yLCBHdGtQcmludFNl dHRpbmdzICoqdXBkYXRlZF9zZXR0aW5ncykKIHsKLSAgICBnX3dhcm5pbmcoIlByaW50aW5nIHN1 cHBvcnQgaXMgbm90IGF2YWlsYWJsZSBpbiBvbGRlciB2ZXJzaW9ucyBvZiBHVEsrIik7CisgICAg ZnJhbWVfcHJpbnQoZnJhbWUsIHNldHRpbmdzLCBwYWdlX3NldHVwLCBOVUxMLCBlcnJvciwgdXBk YXRlZF9zZXR0aW5ncyk7CiB9CiAKICNlbmRpZgpJbmRleDogV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViZnJhbWUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJm cmFtZS5oCShyZXZpc2lvbiAzOTMzNSkKKysrIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZy YW1lLmgJKHdvcmtpbmcgY29weSkKQEAgLTIyLDYgKzIyLDggQEAKICNkZWZpbmUgV0VCS0lUX1dF Ql9GUkFNRV9ICiAKICNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPGd0ay9ndGsu aD4KKwogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTQmFzZS5oPgogCiAjaW5jbHVkZSA8d2Vi a2l0L3dlYmtpdGRlZmluZXMuaD4KQEAgLTk3LDYgKzk5LDIyIEBACiBXRUJLSVRfQVBJIEpTR2xv YmFsQ29udGV4dFJlZgogd2Via2l0X3dlYl9mcmFtZV9nZXRfZ2xvYmFsX2NvbnRleHQgKFdlYktp dFdlYkZyYW1lICAgICAgICpmcmFtZSk7CiAKKyNpZiBHVEtfQ0hFQ0tfVkVSU0lPTigyLDEwLDAp CitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnQgICAgICAgICAgICAgIChX ZWJLaXRXZWJGcmFtZSAgICpmcmFtZSwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIEd0a1BhZ2VTZXR1cCAgICAgKnNldHVwLCAKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBHRXJyb3IgICAgICAgICAgICoqZXJyb3IsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR3RrUHJpbnRTZXR0aW5ncyAqKnVwZGF0ZWRf c2V0dGluZ3MpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnRfdG9f ZmlsZSAgICAgIChXZWJLaXRXZWJGcmFtZSAgICpmcmFtZSwgCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1BhZ2VTZXR1cCAgICAgKnNldHVwLCAKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAgICAgICpmaWxl bmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHRXJyb3IgICAgICAg ICAgICoqZXJyb3IpOworI2VuZGlmCisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpJbmRleDogV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuaAkocmV2aXNpb24gMzkzMzUpCisrKyBXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEzOCw5ICsxMzgsNiBAQAog ICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0X3dlYl9mcmFtZV9nZXRfaW5uZXJfdGV4 dCAoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKIAotICAgIFdFQktJVF9BUEkgdm9pZAotICAgIHdl YmtpdF93ZWJfZnJhbWVfcHJpbnQgKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7Ci0KICAgICBXRUJL SVRfQVBJIGdjaGFyKgogICAgIHdlYmtpdF93ZWJfZnJhbWVfZHVtcF9yZW5kZXJfdHJlZSAoV2Vi S2l0V2ViRnJhbWUqIGZyYW1lKTsKIAo= 26147 2008-12-19 10:12:07 -0800 2009-02-11 02:42:00 -0800 updated patch that fixes CodingStyle & Changelog webkit_print.3.patch text/plain 8264 colin SW5kZXg6IFdlYktpdC9ndGsvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvQ2hh bmdlTG9nCShyZXZpc2lvbiAzOTQwNykKKysrIFdlYktpdC9ndGsvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDgtMTItMTkgIENvbGluIExlcm95ICA8Y29saW5A Y29saW5vLm5ldD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJL aXQ6OkNocm9tZUNsaWVudDo6cHJpbnQpOiB1cGRhdGUgdG8gbmV3IHByaW50aW5nIEFQSQorICAg ICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6IHJlbW92ZSBvbGQgcHJpbnRpbmcgQVBJCisg ICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Vi a2l0d2ViZnJhbWUuaDogVXBkYXRlIHByaW50aW5nIEFQSTsgYWxsb3cgcGFzc2luZworCUd0a1Bh Z2VTZXR1cCBhbmQgR3RrUHJpbnRTZXR0aW5ncywgYWxsb3cgY2FsbGVyIHRvIGdldCB1cGRhdGVk CisJR3RrUHJpbnRTZXR0aW5ncywgYW5kIGFkZCBhIGZ1bmN0aW9uIHRvIGV4cG9ydCB0byBmaWxl LgorCiAyMDA4LTEyLTE4ICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KSW5kZXg6IFdlYktpdC9ndGsvV2ViQ29yZVN1cHBv cnQvQ2hyb21lQ2xpZW50R3RrLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL1dlYkNvcmVT dXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAJKHJldmlzaW9uIDM5MzM1KQorKysgV2ViS2l0L2d0 ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0z ODUsNyArMzg1LDI2IEBAIHZvaWQgQ2hyb21lQ2xpZW50OjpzZXRUb29sVGlwKGNvbnN0IFN0cmkK IAogdm9pZCBDaHJvbWVDbGllbnQ6OnByaW50KEZyYW1lKiBmcmFtZSkKIHsKLSAgICB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50KGtpdChmcmFtZSkpOworICAgIEdFcnJvciAqZXJyb3IgPSBOVUxMOwor ICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoa2l0KGZyYW1lKSwgTlVMTCwgTlVMTCwgJmVycm9y LCBOVUxMKTsKKyAgICBpZiAoIWVycm9yKSB7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAg ICBHdGtXaWRnZXQqIHRvcExldmVsID0gZ3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RLX1dJREdF VCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhraXQoZnJhbWUpKSkpOworICAgIGlmICgh R1RLX1dJREdFVF9UT1BMRVZFTCh0b3BMZXZlbCkpIHsKKyAgICAgICAgdG9wTGV2ZWwgPSBOVUxM OworICAgIH0KKworICAgIEd0a1dpZGdldCogZGlhbG9nID0gZ3RrX21lc3NhZ2VfZGlhbG9nX25l dyhHVEtfV0lORE9XKHRvcExldmVsKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19E SUFMT0dfREVTVFJPWV9XSVRIX1BBUkVOVCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIEdU S19NRVNTQUdFX0VSUk9SLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX0JVVFRPTlNf Q0xPU0UsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAiJXMiLCBlcnJvci0+bWVzc2FnZSk7 CisgICAgZ19lcnJvcl9mcmVlKGVycm9yKTsKKworICAgIGdfc2lnbmFsX2Nvbm5lY3QoZGlhbG9n LCAicmVzcG9uc2UiLCBHX0NBTExCQUNLKGd0a193aWRnZXRfZGVzdHJveSksIE5VTEwpOworICAg IGd0a193aWRnZXRfc2hvdyhkaWFsb2cpOwogfQogCiB2b2lkIENocm9tZUNsaWVudDo6ZXhjZWVk ZWREYXRhYmFzZVF1b3RhKEZyYW1lKiBmcmFtZSwgY29uc3QgU3RyaW5nJikKSW5kZXg6IFdlYktp dC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmgJKHJldmlzaW9uIDM5MzM1KQorKysgV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMzgsOSArMTM4LDYgQEAgZXh0 ZXJuICJDIiB7CiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX2ZyYW1lX2dl dF9pbm5lcl90ZXh0IChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogCi0gICAgV0VCS0lUX0FQSSB2 b2lkCi0gICAgd2Via2l0X3dlYl9mcmFtZV9wcmludCAoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsK LQogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0X3dlYl9mcmFtZV9kdW1wX3JlbmRl cl90cmVlIChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogCkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJmcmFtZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViZnJhbWUuY3BwCShyZXZpc2lvbiAzOTMzNSkKKysrIFdlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYmZyYW1lLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNSw2ICs1LDcgQEAKICAqIENvcHly aWdodCAoQykgMjAwOCBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlvLmNvbT4KICAq IENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgogICogQ29weXJpZ2h0IChDKSAyMDA4 IE51YW50aSBMdGQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDggQ29saW4gTGVyb3kgPGNvbGluQGNv bGluby5uZXQ+LgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC01NDgsNyArNTQ5LDcgQEAgc3RhdGlj IHZvaWQgZW5kX3ByaW50KEd0a1ByaW50T3BlcmF0aW9uKgogICAgIHByaW50Q29udGV4dC0+ZW5k KCk7CiB9CiAKLXZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSogZnJh bWUpCitzdGF0aWMgdm9pZCBmcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1By aW50U2V0dGluZ3MgKnNldHRpbmdzLCBHdGtQYWdlU2V0dXAgKnBhZ2Vfc2V0dXAsIGNvbnN0IGdj aGFyICpmaWxlbmFtZSwgR0Vycm9yICoqZXJyb3IsIEd0a1ByaW50U2V0dGluZ3MgKip1cGRhdGVk X3NldHRpbmdzKQogewogICAgIEd0a1dpZGdldCogdG9wTGV2ZWwgPSBndGtfd2lkZ2V0X2dldF90 b3BsZXZlbChHVEtfV0lER0VUKHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3dlYl92aWV3KGZyYW1lKSkp OwogICAgIGlmICghR1RLX1dJREdFVF9UT1BMRVZFTCh0b3BMZXZlbCkpCkBAIC01NTgsMzMgKzU1 OSw2NyBAQCB2b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJhCiAgICAgQVNT RVJUKGNvcmVGcmFtZSk7CiAKICAgICBQcmludENvbnRleHQgcHJpbnRDb250ZXh0KGNvcmVGcmFt ZSk7CisgICAgR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gYWN0aW9uOwogCiAgICAgR3RrUHJpbnRP cGVyYXRpb24qIG9wID0gZ3RrX3ByaW50X29wZXJhdGlvbl9uZXcoKTsKICAgICBnX3NpZ25hbF9j b25uZWN0KG9wLCAiYmVnaW4tcHJpbnQiLCBHX0NBTExCQUNLKGJlZ2luX3ByaW50KSwgJnByaW50 Q29udGV4dCk7CiAgICAgZ19zaWduYWxfY29ubmVjdChvcCwgImRyYXctcGFnZSIsIEdfQ0FMTEJB Q0soZHJhd19wYWdlKSwgJnByaW50Q29udGV4dCk7CiAgICAgZ19zaWduYWxfY29ubmVjdChvcCwg ImVuZC1wcmludCIsIEdfQ0FMTEJBQ0soZW5kX3ByaW50KSwgJnByaW50Q29udGV4dCk7Ci0gICAg R0Vycm9yICplcnJvciA9IE5VTEw7Ci0gICAgZ3RrX3ByaW50X29wZXJhdGlvbl9ydW4ob3AsIEdU S19QUklOVF9PUEVSQVRJT05fQUNUSU9OX1BSSU5UX0RJQUxPRywgR1RLX1dJTkRPVyh0b3BMZXZl bCksICZlcnJvcik7Ci0gICAgZ19vYmplY3RfdW5yZWYob3ApOwogCi0gICAgaWYgKGVycm9yKSB7 Ci0gICAgICAgIEd0a1dpZGdldCogZGlhbG9nID0gZ3RrX21lc3NhZ2VfZGlhbG9nX25ldyhHVEtf V0lORE9XKHRvcExldmVsKSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEdUS19ESUFMT0dfREVTVFJPWV9XSVRIX1BBUkVOVCwKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19NRVNTQUdFX0VSUk9S LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RL X0JVVFRPTlNfQ0xPU0UsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAiJXMiLCBlcnJvci0+bWVzc2FnZSk7Ci0gICAgICAgIGdfZXJyb3JfZnJlZShl cnJvcik7CisgICAgaWYgKGZpbGVuYW1lKSB7CisgICAgICAgIGd0a19wcmludF9vcGVyYXRpb25f c2V0X2V4cG9ydF9maWxlbmFtZShvcCwgZmlsZW5hbWUpOworICAgICAgICBhY3Rpb24gPSBHVEtf UFJJTlRfT1BFUkFUSU9OX0FDVElPTl9FWFBPUlQ7CisgICAgfSBlbHNlIHsKKyAgICAgICAgYWN0 aW9uID0gR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fUFJJTlRfRElBTE9HOworICAgIH0KKwor ICAgIGlmIChzZXR0aW5ncykKKyAgICAgICAgZ3RrX3ByaW50X29wZXJhdGlvbl9zZXRfcHJpbnRf c2V0dGluZ3Mob3AsIHNldHRpbmdzKTsKKyAgICBpZiAocGFnZV9zZXR1cCkKKyAgICAgICAgZ3Rr X3ByaW50X29wZXJhdGlvbl9zZXRfZGVmYXVsdF9wYWdlX3NldHVwKG9wLCBwYWdlX3NldHVwKTsK IAotICAgICAgICBnX3NpZ25hbF9jb25uZWN0KGRpYWxvZywgInJlc3BvbnNlIiwgR19DQUxMQkFD SyhndGtfd2lkZ2V0X2Rlc3Ryb3kpLCBOVUxMKTsKLSAgICAgICAgZ3RrX3dpZGdldF9zaG93KGRp YWxvZyk7CisKKyAgICBHdGtQcmludE9wZXJhdGlvblJlc3VsdCByZXN1bHQgPSBndGtfcHJpbnRf b3BlcmF0aW9uX3J1bihvcCwgYWN0aW9uLCBHVEtfV0lORE9XKHRvcExldmVsKSwgZXJyb3IpOwor ICAgIGlmIChyZXN1bHQgPT0gR1RLX1BSSU5UX09QRVJBVElPTl9SRVNVTFRfQVBQTFkgJiYgdXBk YXRlZF9zZXR0aW5ncykgeworICAgICAgICAvKiAKKyAgICAgICAgICogSWYgdGhlIHVzZXIgcHJp bnRlZCwgYW5kIHRoZSBjYWxsZXIgaXMgaW50ZXJlc3RlZCBpbiB1cGRhdGVkIHNldHRpbmdzLCAK KyAgICAgICAgICogZ2l2ZSB0aGVtIGJhY2sgdG8gaGltIAorICAgICAgICAgKi8KKyAgICAgICAg KnVwZGF0ZWRfc2V0dGluZ3MgPSAoR3RrUHJpbnRTZXR0aW5ncyAqKWdfb2JqZWN0X3JlZiAoZ3Rr X3ByaW50X29wZXJhdGlvbl9nZXRfcHJpbnRfc2V0dGluZ3MgKG9wKSk7CiAgICAgfQorCisgICAg Z19vYmplY3RfdW5yZWYob3ApOworCiB9CiAKLSNlbHNlCisvKioKKyAqIHdlYmtpdF93ZWJfZnJh bWVfcHJpbnRfdG9fZmlsZToKKyAqIEBmcmFtZTogYSAjV2ViS2l0V2ViRnJhbWUKKyAqIEBzZXR0 aW5nczogI0d0a1ByaW50U2V0dGluZ3MgdG8gYXBwbHksIG9yIE5VTEwgdG8gdXNlIGRlZmF1bHRz CisgKiBAcGFnZV9zZXR1cDogI0d0a1BhZ2VTZXR1cCB0byB1c2UsIG9yIE5VTEwgdG8gdXNlIGRl ZmF1bHRzCisgKiBAZmlsZW5hbWU6IG91dHB1dCBmaWxlbmFtZSB0byBzdG9yZSB0aGUgcHJpbnQg cmVzdWx0CisgKiBAZXJyb3I6ICNHRXJyb3IgdG8gc3RvcmUgYSBwb3NzaWJsZSBlcnJvciBtZXNz YWdlCisgKgorICogUHJpbnRzIHRoZSBnaXZlbiBmcmFtZSB0byBmaWxlLgorICovCit2b2lkIHdl YmtpdF93ZWJfZnJhbWVfcHJpbnRfdG9fZmlsZShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1By aW50U2V0dGluZ3MgKnNldHRpbmdzLCBHdGtQYWdlU2V0dXAgKnBhZ2Vfc2V0dXAsIGNvbnN0IGdj aGFyICpmaWxlbmFtZSwgR0Vycm9yICoqZXJyb3IpCit7CisgICAgZnJhbWVfcHJpbnQoZnJhbWUs IHNldHRpbmdzLCBwYWdlX3NldHVwLCBmaWxlbmFtZSwgZXJyb3IsIE5VTEwpOworfQogCi12b2lk IHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJhbWUqKQorLyoqCisgKiB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50OgorICogQGZyYW1lOiBhICNXZWJLaXRXZWJGcmFtZQorICogQHNldHRp bmdzOiAjR3RrUHJpbnRTZXR0aW5ncyB0byBhcHBseSwgb3IgTlVMTCB0byB1c2UgZGVmYXVsdHMK KyAqIEBwYWdlX3NldHVwOiAjR3RrUGFnZVNldHVwIHRvIHVzZSwgb3IgTlVMTCB0byB1c2UgZGVm YXVsdHMKKyAqIEBlcnJvcjogI0dFcnJvciB0byBzdG9yZSBhIHBvc3NpYmxlIGVycm9yIG1lc3Nh Z2UKKyAqIEB1cGRhdGVkX3NldHRpbmdzOiBuZXcgI0d0a1ByaW50U2V0dGluZ3MgcmVmbGVjdGlu ZyB0aGUgcG9zc2libGUgY2hhbmdlcyBkb25lIGluIHRoZSBkaWFsb2cuCisgKgorICogUHJpbnRz IHRoZSBnaXZlbiBmcmFtZSBhZnRlciBkaXNwbGF5aW5nIHRoZSBHVEsgcHJpbnRpbmcgZGlhbG9n LgorICovCit2b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJhbWUqIGZyYW1l LCBHdGtQcmludFNldHRpbmdzICpzZXR0aW5ncywgR3RrUGFnZVNldHVwICpwYWdlX3NldHVwLCBH RXJyb3IgKiplcnJvciwgR3RrUHJpbnRTZXR0aW5ncyAqKnVwZGF0ZWRfc2V0dGluZ3MpCiB7Ci0g ICAgZ193YXJuaW5nKCJQcmludGluZyBzdXBwb3J0IGlzIG5vdCBhdmFpbGFibGUgaW4gb2xkZXIg dmVyc2lvbnMgb2YgR1RLKyIpOworICAgIGZyYW1lX3ByaW50KGZyYW1lLCBzZXR0aW5ncywgcGFn ZV9zZXR1cCwgTlVMTCwgZXJyb3IsIHVwZGF0ZWRfc2V0dGluZ3MpOwogfQogCiAjZW5kaWYKSW5k ZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAkocmV2aXNpb24gMzkzMzUpCisrKyBXZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMiw2ICsy Miw4IEBACiAjZGVmaW5lIFdFQktJVF9XRUJfRlJBTUVfSAogCiAjaW5jbHVkZSA8Z2xpYi1vYmpl Y3QuaD4KKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9K U0Jhc2UuaD4KIAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CkBAIC05Nyw2ICs5 OSwyMiBAQCB3ZWJraXRfd2ViX2ZyYW1lX2ZpbmRfZnJhbWUgICAgICAgICAoV2ViCiBXRUJLSVRf QVBJIEpTR2xvYmFsQ29udGV4dFJlZgogd2Via2l0X3dlYl9mcmFtZV9nZXRfZ2xvYmFsX2NvbnRl eHQgKFdlYktpdFdlYkZyYW1lICAgICAgICpmcmFtZSk7CiAKKyNpZiBHVEtfQ0hFQ0tfVkVSU0lP TigyLDEwLDApCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnQgICAgICAg ICAgICAgIChXZWJLaXRXZWJGcmFtZSAgICpmcmFtZSwgCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1BhZ2VTZXR1cCAgICAgKnNldHVwLCAKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHRXJyb3IgICAgICAgICAgICoqZXJyb3Is CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR3RrUHJpbnRTZXR0aW5ncyAq KnVwZGF0ZWRfc2V0dGluZ3MpOworCitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfZnJhbWVf cHJpbnRfdG9fZmlsZSAgICAgIChXZWJLaXRXZWJGcmFtZSAgICpmcmFtZSwgCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1BhZ2VTZXR1cCAgICAgKnNl dHVwLCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciAg ICAgICpmaWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHRXJy b3IgICAgICAgICAgICoqZXJyb3IpOworI2VuZGlmCisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgo= 27556 2009-02-11 02:42:00 -0800 2009-03-23 12:17:55 -0700 Updated patch to have similar API with older GTK webkit_web_frame_print_to_file.2009-02-11.patch text/plain 10145 colin SW5kZXg6IFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAJ KHJldmlzaW9uIDQwODUzKQorKysgV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGll bnRHdGsuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOTAsNyArMzkwLDI2IEBACiAKIHZvaWQgQ2hy b21lQ2xpZW50OjpwcmludChGcmFtZSogZnJhbWUpCiB7Ci0gICAgd2Via2l0X3dlYl9mcmFtZV9w cmludChraXQoZnJhbWUpKTsKKyAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKKyAgICB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50KGtpdChmcmFtZSksIE5VTEwsIE5VTEwsICZlcnJvciwgTlVMTCk7Cisg ICAgaWYgKCFlcnJvcikgeworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgR3RrV2lkZ2V0 KiB0b3BMZXZlbCA9IGd0a193aWRnZXRfZ2V0X3RvcGxldmVsKEdUS19XSURHRVQod2Via2l0X3dl Yl9mcmFtZV9nZXRfd2ViX3ZpZXcoa2l0KGZyYW1lKSkpKTsKKyAgICBpZiAoIUdUS19XSURHRVRf VE9QTEVWRUwodG9wTGV2ZWwpKSB7CisgICAgICAgIHRvcExldmVsID0gTlVMTDsKKyAgICB9CisK KyAgICBHdGtXaWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxvZ19uZXcoR1RLX1dJTkRP Vyh0b3BMZXZlbCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElBTE9HX0RFU1RS T1lfV0lUSF9QQVJFTlQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfTUVTU0FHRV9F UlJPUiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NFLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgIiVzIiwgZXJyb3ItPm1lc3NhZ2UpOworICAgIGdfZXJy b3JfZnJlZShlcnJvcik7CisKKyAgICBnX3NpZ25hbF9jb25uZWN0KGRpYWxvZywgInJlc3BvbnNl IiwgR19DQUxMQkFDSyhndGtfd2lkZ2V0X2Rlc3Ryb3kpLCBOVUxMKTsKKyAgICBndGtfd2lkZ2V0 X3Nob3coZGlhbG9nKTsKIH0KIAogdm9pZCBDaHJvbWVDbGllbnQ6OmV4Y2VlZGVkRGF0YWJhc2VR dW90YShGcmFtZSogZnJhbWUsIGNvbnN0IFN0cmluZyYpCkluZGV4OiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJmcmFtZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViZnJhbWUuY3BwCShyZXZpc2lvbiA0MDg1MykKKysrIFdlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYmZyYW1lLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNSw2ICs1LDcgQEAKICAqIENvcHly aWdodCAoQykgMjAwOCBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlvLmNvbT4KICAq IENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgogICogQ29weXJpZ2h0IChDKSAyMDA4 IE51YW50aSBMdGQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQ29saW4gTGVyb3kgPGNvbGluQGNv bGluby5uZXQ+LgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC01ODksNyArNTkwLDcgQEAKICAgICBw cmludENvbnRleHQtPmVuZCgpOwogfQogCi12b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2Vi S2l0V2ViRnJhbWUqIGZyYW1lKQorc3RhdGljIHZvaWQgZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJh bWUqIGZyYW1lLCBHdGtQcmludFNldHRpbmdzICpzZXR0aW5ncywgR3RrUGFnZVNldHVwICpwYWdl X3NldHVwLCBjb25zdCBnY2hhciAqZmlsZW5hbWUsIEdFcnJvciAqKmVycm9yLCBHdGtQcmludFNl dHRpbmdzICoqdXBkYXRlZF9zZXR0aW5ncykKIHsKICAgICBHdGtXaWRnZXQqIHRvcExldmVsID0g Z3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RLX1dJREdFVCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93 ZWJfdmlldyhmcmFtZSkpKTsKICAgICBpZiAoIUdUS19XSURHRVRfVE9QTEVWRUwodG9wTGV2ZWwp KQpAQCAtNjAwLDM1ICs2MDEsMTAxIEBACiAgICAgICAgIHJldHVybjsKIAogICAgIFByaW50Q29u dGV4dCBwcmludENvbnRleHQoY29yZUZyYW1lKTsKKyAgICBHdGtQcmludE9wZXJhdGlvbkFjdGlv biBhY3Rpb247CiAKICAgICBHdGtQcmludE9wZXJhdGlvbiogb3AgPSBndGtfcHJpbnRfb3BlcmF0 aW9uX25ldygpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJiZWdpbi1wcmludCIsIEdfQ0FM TEJBQ0soYmVnaW5fcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsKICAgICBnX3NpZ25hbF9jb25uZWN0 KG9wLCAiZHJhdy1wYWdlIiwgR19DQUxMQkFDSyhkcmF3X3BhZ2UpLCAmcHJpbnRDb250ZXh0KTsK ICAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiZW5kLXByaW50IiwgR19DQUxMQkFDSyhlbmRfcHJp bnQpLCAmcHJpbnRDb250ZXh0KTsKLSAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKLSAgICBndGtf cHJpbnRfb3BlcmF0aW9uX3J1bihvcCwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fUFJJTlRf RElBTE9HLCBHVEtfV0lORE9XKHRvcExldmVsKSwgJmVycm9yKTsKLSAgICBnX29iamVjdF91bnJl ZihvcCk7CiAKLSAgICBpZiAoZXJyb3IpIHsKLSAgICAgICAgR3RrV2lkZ2V0KiBkaWFsb2cgPSBn dGtfbWVzc2FnZV9kaWFsb2dfbmV3KEdUS19XSU5ET1codG9wTGV2ZWwpLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX0RJQUxPR19ERVNUUk9Z X1dJVEhfUEFSRU5ULAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgR1RLX01FU1NBR0VfRVJST1IsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBHVEtfQlVUVE9OU19DTE9TRSwKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICIlcyIsIGVycm9yLT5tZXNzYWdl KTsKLSAgICAgICAgZ19lcnJvcl9mcmVlKGVycm9yKTsKKyAgICBpZiAoZmlsZW5hbWUpIHsKKyAg ICAgICAgZ3RrX3ByaW50X29wZXJhdGlvbl9zZXRfZXhwb3J0X2ZpbGVuYW1lKG9wLCBmaWxlbmFt ZSk7CisgICAgICAgIGFjdGlvbiA9IEdUS19QUklOVF9PUEVSQVRJT05fQUNUSU9OX0VYUE9SVDsK KyAgICB9IGVsc2UgeworICAgICAgICBhY3Rpb24gPSBHVEtfUFJJTlRfT1BFUkFUSU9OX0FDVElP Tl9QUklOVF9ESUFMT0c7CisgICAgfQogCi0gICAgICAgIGdfc2lnbmFsX2Nvbm5lY3QoZGlhbG9n LCAicmVzcG9uc2UiLCBHX0NBTExCQUNLKGd0a193aWRnZXRfZGVzdHJveSksIE5VTEwpOwotICAg ICAgICBndGtfd2lkZ2V0X3Nob3coZGlhbG9nKTsKKyAgICBpZiAoc2V0dGluZ3MpCisgICAgICAg IGd0a19wcmludF9vcGVyYXRpb25fc2V0X3ByaW50X3NldHRpbmdzKG9wLCBzZXR0aW5ncyk7Cisg ICAgaWYgKHBhZ2Vfc2V0dXApCisgICAgICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X2RlZmF1 bHRfcGFnZV9zZXR1cChvcCwgcGFnZV9zZXR1cCk7CisKKworICAgIEd0a1ByaW50T3BlcmF0aW9u UmVzdWx0IHJlc3VsdCA9IGd0a19wcmludF9vcGVyYXRpb25fcnVuKG9wLCBhY3Rpb24sIEdUS19X SU5ET1codG9wTGV2ZWwpLCBlcnJvcik7CisgICAgaWYgKHJlc3VsdCA9PSBHVEtfUFJJTlRfT1BF UkFUSU9OX1JFU1VMVF9BUFBMWSAmJiB1cGRhdGVkX3NldHRpbmdzKSB7CisgICAgICAgIC8qIAor ICAgICAgICAgKiBJZiB0aGUgdXNlciBwcmludGVkLCBhbmQgdGhlIGNhbGxlciBpcyBpbnRlcmVz dGVkIGluIHVwZGF0ZWQgc2V0dGluZ3MsIAorICAgICAgICAgKiBnaXZlIHRoZW0gYmFjayB0byBo aW0gCisgICAgICAgICAqLworICAgICAgICAqdXBkYXRlZF9zZXR0aW5ncyA9IChHdGtQcmludFNl dHRpbmdzICopZ19vYmplY3RfcmVmIChndGtfcHJpbnRfb3BlcmF0aW9uX2dldF9wcmludF9zZXR0 aW5ncyAob3ApKTsKICAgICB9CisKKyAgICBnX29iamVjdF91bnJlZihvcCk7CisKIH0KIAotI2Vs c2UKKy8qKgorICogd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19maWxlOgorICogQGZyYW1lOiBh ICNXZWJLaXRXZWJGcmFtZQorICogQHNldHRpbmdzOiAjR3RrUHJpbnRTZXR0aW5ncyB0byBhcHBs eSwgb3IgTlVMTCB0byB1c2UgZGVmYXVsdHMKKyAqIEBwYWdlX3NldHVwOiAjR3RrUGFnZVNldHVw IHRvIHVzZSwgb3IgTlVMTCB0byB1c2UgZGVmYXVsdHMKKyAqIEBmaWxlbmFtZTogb3V0cHV0IGZp bGVuYW1lIHRvIHN0b3JlIHRoZSBwcmludCByZXN1bHQKKyAqIEBlcnJvcjogI0dFcnJvciB0byBz dG9yZSBhIHBvc3NpYmxlIGVycm9yIG1lc3NhZ2UKKyAqCisgKiBQcmludHMgdGhlIGdpdmVuIGZy YW1lIHRvIGZpbGUuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludF90b19maWxlKFdl YktpdFdlYkZyYW1lKiBmcmFtZSwgR3RrUHJpbnRTZXR0aW5ncyAqc2V0dGluZ3MsIEd0a1BhZ2VT ZXR1cCAqcGFnZV9zZXR1cCwgY29uc3QgZ2NoYXIgKmZpbGVuYW1lLCBHRXJyb3IgKiplcnJvcikK K3sKKyAgICBmcmFtZV9wcmludChmcmFtZSwgc2V0dGluZ3MsIHBhZ2Vfc2V0dXAsIGZpbGVuYW1l LCBlcnJvciwgTlVMTCk7Cit9CiAKLXZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRX ZWJGcmFtZSopCisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6CisgKiBAZnJhbWU6IGEg I1dlYktpdFdlYkZyYW1lCisgKiBAc2V0dGluZ3M6ICNHdGtQcmludFNldHRpbmdzIHRvIGFwcGx5 LCBvciBOVUxMIHRvIHVzZSBkZWZhdWx0cworICogQHBhZ2Vfc2V0dXA6ICNHdGtQYWdlU2V0dXAg dG8gdXNlLCBvciBOVUxMIHRvIHVzZSBkZWZhdWx0cworICogQGVycm9yOiAjR0Vycm9yIHRvIHN0 b3JlIGEgcG9zc2libGUgZXJyb3IgbWVzc2FnZQorICogQHVwZGF0ZWRfc2V0dGluZ3M6IG5ldyAj R3RrUHJpbnRTZXR0aW5ncyByZWZsZWN0aW5nIHRoZSBwb3NzaWJsZSBjaGFuZ2VzIGRvbmUgaW4g dGhlIGRpYWxvZy4KKyAqCisgKiBQcmludHMgdGhlIGdpdmVuIGZyYW1lIGFmdGVyIGRpc3BsYXlp bmcgdGhlIEdUSyBwcmludGluZyBkaWFsb2cuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9w cmludChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50U2V0dGluZ3MgKnNldHRpbmdzLCBH dGtQYWdlU2V0dXAgKnBhZ2Vfc2V0dXAsIEdFcnJvciAqKmVycm9yLCBHdGtQcmludFNldHRpbmdz ICoqdXBkYXRlZF9zZXR0aW5ncykKIHsKKyAgICBmcmFtZV9wcmludChmcmFtZSwgc2V0dGluZ3Ms IHBhZ2Vfc2V0dXAsIE5VTEwsIGVycm9yLCB1cGRhdGVkX3NldHRpbmdzKTsKK30KKworI2Vsc2Ug LyogR1RLX0NIRUNLX1ZFUlNJT04oMiwxMCwwKSAqLworCisvKioKKyAqIHdlYmtpdF93ZWJfZnJh bWVfcHJpbnRfdG9fZmlsZToKKyAqIEBmcmFtZTogYSAjV2ViS2l0V2ViRnJhbWUKKyAqIEBzZXR0 aW5nczogI0d0a1ByaW50U2V0dGluZ3MgdG8gYXBwbHksIG9yIE5VTEwgdG8gdXNlIGRlZmF1bHRz CisgKiBAcGFnZV9zZXR1cDogI0d0a1BhZ2VTZXR1cCB0byB1c2UsIG9yIE5VTEwgdG8gdXNlIGRl ZmF1bHRzCisgKiBAZmlsZW5hbWU6IG91dHB1dCBmaWxlbmFtZSB0byBzdG9yZSB0aGUgcHJpbnQg cmVzdWx0CisgKiBAZXJyb3I6ICNHRXJyb3IgdG8gc3RvcmUgYSBwb3NzaWJsZSBlcnJvciBtZXNz YWdlCisgKgorICogUHJpbnRzIHRoZSBnaXZlbiBmcmFtZSB0byBmaWxlLgorICovCit2b2lkIHdl YmtpdF93ZWJfZnJhbWVfcHJpbnRfdG9fZmlsZShXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1By aW50U2V0dGluZ3MgKnNldHRpbmdzLCBHdGtQYWdlU2V0dXAgKnBhZ2Vfc2V0dXAsIGNvbnN0IGdj aGFyICpmaWxlbmFtZSwgR0Vycm9yICoqZXJyb3IpCit7CiAgICAgZ193YXJuaW5nKCJQcmludGlu ZyBzdXBwb3J0IGlzIG5vdCBhdmFpbGFibGUgaW4gb2xkZXIgdmVyc2lvbnMgb2YgR1RLKyIpOwog fQogCisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6CisgKiBAZnJhbWU6IGEgI1dlYktp dFdlYkZyYW1lCisgKiBAc2V0dGluZ3M6ICNHdGtQcmludFNldHRpbmdzIHRvIGFwcGx5LCBvciBO VUxMIHRvIHVzZSBkZWZhdWx0cworICogQHBhZ2Vfc2V0dXA6ICNHdGtQYWdlU2V0dXAgdG8gdXNl LCBvciBOVUxMIHRvIHVzZSBkZWZhdWx0cworICogQGVycm9yOiAjR0Vycm9yIHRvIHN0b3JlIGEg cG9zc2libGUgZXJyb3IgbWVzc2FnZQorICogQHVwZGF0ZWRfc2V0dGluZ3M6IG5ldyAjR3RrUHJp bnRTZXR0aW5ncyByZWZsZWN0aW5nIHRoZSBwb3NzaWJsZSBjaGFuZ2VzIGRvbmUgaW4gdGhlIGRp YWxvZy4KKyAqCisgKiBQcmludHMgdGhlIGdpdmVuIGZyYW1lIGFmdGVyIGRpc3BsYXlpbmcgdGhl IEdUSyBwcmludGluZyBkaWFsb2cuCisgKi8KK3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChX ZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50U2V0dGluZ3MgKnNldHRpbmdzLCBHdGtQYWdl U2V0dXAgKnBhZ2Vfc2V0dXAsIEdFcnJvciAqKmVycm9yLCBHdGtQcmludFNldHRpbmdzICoqdXBk YXRlZF9zZXR0aW5ncykKK3sKKyAgICBnX3dhcm5pbmcoIlByaW50aW5nIHN1cHBvcnQgaXMgbm90 IGF2YWlsYWJsZSBpbiBvbGRlciB2ZXJzaW9ucyBvZiBHVEsrIik7Cit9CisKICNlbmRpZgogCiBi b29sIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2VfYW5pbWF0aW9uKFdlYktpdFdlYkZyYW1lKiBmcmFt ZSwgY29uc3QgZ2NoYXIqIG5hbWUsIGRvdWJsZSB0aW1lLCBjb25zdCBnY2hhciogZWxlbWVudCkK SW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAkocmV2aXNpb24gNDA4NTMpCisrKyBX ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMiw2 ICsyMiw4IEBACiAjZGVmaW5lIFdFQktJVF9XRUJfRlJBTUVfSAogCiAjaW5jbHVkZSA8Z2xpYi1v YmplY3QuaD4KKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9KU0Jhc2UuaD4KIAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CkBAIC05Nyw2 ICs5OSwzNSBAQAogV0VCS0lUX0FQSSBKU0dsb2JhbENvbnRleHRSZWYKIHdlYmtpdF93ZWJfZnJh bWVfZ2V0X2dsb2JhbF9jb250ZXh0IChXZWJLaXRXZWJGcmFtZSAgICAgICAqZnJhbWUpOwogCisj aWYgR1RLX0NIRUNLX1ZFUlNJT04oMiwxMCwwKQorV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfd2Vi X2ZyYW1lX3ByaW50ICAgICAgICAgICAgICAoV2ViS2l0V2ViRnJhbWUgICAqZnJhbWUsIAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1ByaW50U2V0dGluZ3MgKnNldHRp bmdzLCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHdGtQYWdlU2V0dXAg ICAgICpzZXR1cCwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0Vycm9y ICAgICAgICAgICAqKmVycm9yLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEd0a1ByaW50U2V0dGluZ3MgKip1cGRhdGVkX3NldHRpbmdzKTsKKworV0VCS0lUX0FQSSB2b2lk Cit3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X3RvX2ZpbGUgICAgICAoV2ViS2l0V2ViRnJhbWUgICAq ZnJhbWUsIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1ByaW50U2V0 dGluZ3MgKnNldHRpbmdzLCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBH dGtQYWdlU2V0dXAgICAgICpzZXR1cCwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgY29uc3QgZ2NoYXIgICAgICAqZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR0Vycm9yICAgICAgICAgICAqKmVycm9yKTsKKyNlbHNlCit3ZWJraXRf d2ViX2ZyYW1lX3ByaW50ICAgICAgICAgICAgICAoV2ViS2l0V2ViRnJhbWUgICAqZnJhbWUsIAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQJICAgICAgKnNldHRpbmdz LCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICAgICAgICAgICAg ICpzZXR1cCwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0Vycm9yICAg ICAgICAgICAqKmVycm9yLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZv aWQgICAgICAgICAgICAgKip1cGRhdGVkX3NldHRpbmdzKTsKKworV0VCS0lUX0FQSSB2b2lkCit3 ZWJraXRfd2ViX2ZyYW1lX3ByaW50X3RvX2ZpbGUgICAgICAoV2ViS2l0V2ViRnJhbWUgICAqZnJh bWUsIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgICAgICAgICAg ICAgKnNldHRpbmdzLCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lk ICAgICAgICAgICAgICpzZXR1cCwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgY29uc3QgZ2NoYXIgICAgICAqZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgR0Vycm9yICAgICAgICAgICAqKmVycm9yKTsKKyNlbmRpZgorCiBHX0VORF9E RUNMUwogCiAjZW5kaWYKSW5kZXg6IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgJKHJldmlzaW9u IDQwODUzKQorKysgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCSh3b3JraW5nIGNv cHkpCkBAIC0xNTIsOSArMTUyLDYgQEAKICAgICBXRUJLSVRfQVBJIGdjaGFyKgogICAgIHdlYmtp dF93ZWJfZnJhbWVfZ2V0X2lubmVyX3RleHQgKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiAKLSAg ICBXRUJLSVRfQVBJIHZvaWQKLSAgICB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50IChXZWJLaXRXZWJG cmFtZSogZnJhbWUpOwotCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX2Zy YW1lX2R1bXBfcmVuZGVyX3RyZWUgKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiAKSW5kZXg6IFdl YktpdC9ndGsvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9ndGsvQ2hhbmdlTG9nCShy ZXZpc2lvbiA0MDg1MykKKysrIFdlYktpdC9ndGsvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTUgQEAKKzIwMDktMDItMTEgIENvbGluIExlcm95ICA8Y29saW5AY29saW5vLm5l dD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdl YkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkNocm9t ZUNsaWVudDo6cHJpbnQpOiB1cGRhdGUgdG8gbmV3IHByaW50aW5nIEFQSQorICAgICAgICAqIHdl YmtpdC93ZWJraXRwcml2YXRlLmg6IHJlbW92ZSBvbGQgcHJpbnRpbmcgQVBJCisgICAgICAgICog d2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJh bWUuaDogVXBkYXRlIHByaW50aW5nIEFQSTsgYWxsb3cgcGFzc2luZworCUd0a1BhZ2VTZXR1cCBh bmQgR3RrUHJpbnRTZXR0aW5ncywgYWxsb3cgY2FsbGVyIHRvIGdldCB1cGRhdGVkCisJR3RrUHJp bnRTZXR0aW5ncywgYW5kIGFkZCBhIGZ1bmN0aW9uIHRvIGV4cG9ydCB0byBmaWxlLgorCiAyMDA5 LTAyLTA3ICBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlciAgPHplY2tlQHNlbGZpc2gub3JnPgog CiAgICAgICAgIFVucmV2aWV3ZWQgYnVpbGQgZml4IFVzZSB0b05vcm1hbGl6ZWRSYW5nZSgpLgo= 28859 2009-03-23 12:17:55 -0700 2009-03-23 12:24:54 -0700 proposed printing API printing.patch text/plain 10965 gustavo RnJvbSA0ZTdkODg5NjllMDEyNDUxYzdlYjIxZjcyYjIzZjkyOWY1NzhiY2JlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBNb24sIDIzIE1hciAyMDA5IDE2OjEyOjQ2IC0wMzAwClN1YmplY3Q6IFtQQVRDSF0g MjAwOS0wMy0yMyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KCiAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjg5OAogICAgICAgIFtHVEtdIG5lZWQgcHJvcGVyIEFQ SSBmb3IgcHJpbnRpbmcKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciBwcmludGluZyBBUEksIHVz aW5nIHRoZSBHVEsrIHByaW50aW5nIEFQSS4KCiAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9DaHJv bWVDbGllbnRHdGsuY3BwOgogICAgICAgIChXZWJLaXQ6OkNocm9tZUNsaWVudDo6cHJpbnQpOgog ICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKICAgICAgICAqIHdlYmtpdC93ZWJraXR3 ZWJmcmFtZS5jcHA6CiAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuaDoKICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKLS0tCiBXZWJLaXQvZ3RrL0NoYW5nZUxvZyAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKysKIFdlYktpdC9ndGsvV2ViQ29yZVN1 cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcCB8ICAgMjYgKysrKysrKysrKystCiBXZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgfCAgICAzIC0KIFdlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCAgICAgICAgICB8ICAgNTQgKysrKysrKysrLS0tLS0t LS0tLS0tLS0tCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oICAgICAgICAgICAg fCAgICA4ICsrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAgICAgICAg ICB8ICAgMjQgKysrKysrKysrKysKIDYgZmlsZXMgY2hhbmdlZCwgOTMgaW5zZXJ0aW9ucygrKSwg MzggZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJL aXQvZ3RrL0NoYW5nZUxvZwppbmRleCA3OWE3MzRlLi5jYjcxMWVjIDEwMDY0NAotLS0gYS9XZWJL aXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5 IEBACisyMDA5LTAzLTIzICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjg5OAorICAgICAgICBbR1RLXSBuZWVk IHByb3BlciBBUEkgZm9yIHByaW50aW5nCisKKyAgICAgICAgSW1wbGVtZW50IHByb3BlciBwcmlu dGluZyBBUEksIHVzaW5nIHRoZSBHVEsrIHByaW50aW5nIEFQSS4KKworICAgICAgICAqIFdlYkNv cmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkNocm9tZUNs aWVudDo6cHJpbnQpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAg ICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vi ZnJhbWUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisKIDIwMDktMDMt MjAgIEphbiBNaWNoYWVsIEFsb256byAgPGptYWxvbnpvQGdtYWlsLmNvbT4KIAogICAgICAgICBO b3QgcmV2aWV3ZWQuIEZpeCBzdHlsZSBpc3N1ZXMgd2l0aCBteSBwcmV2aW91cyBjb21taXQgKHI0 MTg2NikgYXMKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xp ZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNw cAppbmRleCAzNTU3YTNmLi5mMDkzNzFiIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVT dXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAKKysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9DaHJvbWVDbGllbnRHdGsuY3BwCkBAIC0zOTAsNyArMzkwLDMxIEBAIHZvaWQgQ2hyb21lQ2xp ZW50OjpzZXRUb29sVGlwKGNvbnN0IFN0cmluZyYgdG9vbFRpcCkKIAogdm9pZCBDaHJvbWVDbGll bnQ6OnByaW50KEZyYW1lKiBmcmFtZSkKIHsKLSAgICB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50KGtp dChmcmFtZSkpOworICAgIFdlYktpdFdlYkZyYW1lKiB3ZWJGcmFtZSA9IGtpdChmcmFtZSk7Cisg ICAgZ2Jvb2xlYW4gaXNIYW5kbGVkID0gZmFsc2U7CisgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1l KG1fd2ViVmlldywgInByaW50LXJlcXVlc3RlZCIsIHdlYkZyYW1lLCAmaXNIYW5kbGVkKTsKKwor ICAgIGlmIChpc0hhbmRsZWQpCisgICAgICAgIHJldHVybjsKKworICAgIEd0a1ByaW50T3BlcmF0 aW9uKiBvcGVyYXRpb24gPSBndGtfcHJpbnRfb3BlcmF0aW9uX25ldygpOworICAgIEdFcnJvciog ZXJyb3IgPSAwOworCisgICAgd2Via2l0X3dlYl9mcmFtZV9wcmludCh3ZWJGcmFtZSwgb3BlcmF0 aW9uLCBHVEtfUFJJTlRfT1BFUkFUSU9OX0FDVElPTl9QUklOVF9ESUFMT0csICZlcnJvcik7Cisg ICAgZ19vYmplY3RfdW5yZWYob3BlcmF0aW9uKTsKKworICAgIGlmIChlcnJvcikgeworICAgICAg ICBHdGtXaWRnZXQqIHdpbmRvdyA9IGd0a193aWRnZXRfZ2V0X3RvcGxldmVsKEdUS19XSURHRVQo bV93ZWJWaWV3KSk7CisgICAgICAgIEd0a1dpZGdldCogZGlhbG9nID0gZ3RrX21lc3NhZ2VfZGlh bG9nX25ldyhHVEtfV0lER0VUX1RPUExFVkVMKHdpbmRvdykgPyBHVEtfV0lORE9XKHdpbmRvdykg OiAwLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg R1RLX0RJQUxPR19ERVNUUk9ZX1dJVEhfUEFSRU5ULAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX01FU1NBR0VfRVJST1IsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfQlVUVE9OU19DTE9T RSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICIl cyIsIGVycm9yLT5tZXNzYWdlKTsKKyAgICAgICAgZ19lcnJvcl9mcmVlKGVycm9yKTsKKworICAg ICAgICBnX3NpZ25hbF9jb25uZWN0KGRpYWxvZywgInJlc3BvbnNlIiwgR19DQUxMQkFDSyhndGtf d2lkZ2V0X2Rlc3Ryb3kpLCAwKTsKKyAgICAgICAgZ3RrX3dpZGdldF9zaG93KGRpYWxvZyk7Cisg ICAgfQogfQogCiB2b2lkIENocm9tZUNsaWVudDo6ZXhjZWVkZWREYXRhYmFzZVF1b3RhKEZyYW1l KiBmcmFtZSwgY29uc3QgU3RyaW5nJikKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCAw YjgzYTExLi44MjMwYjg2IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCkBAIC0xNzYsOSAr MTc2LDYgQEAgZXh0ZXJuICJDIiB7CiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRf d2ViX2ZyYW1lX2dldF9pbm5lcl90ZXh0IChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogCi0gICAg V0VCS0lUX0FQSSB2b2lkCi0gICAgd2Via2l0X3dlYl9mcmFtZV9wcmludCAoV2ViS2l0V2ViRnJh bWUqIGZyYW1lKTsKLQogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0X3dlYl9mcmFt ZV9kdW1wX3JlbmRlcl90cmVlIChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwogCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggZTJiMTBiNi4uYWFiNTY1MSAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNiw2ICs2LDcgQEAKICAqIENvcHlyaWdodCAoQykg MjAwOCBDb2xsYWJvcmEgTHRkLgogICogQ29weXJpZ2h0IChDKSAyMDA4IE51YW50aSBMdGQuCiAg KiBDb3B5cmlnaHQgKEMpIDIwMDkgSmFuIEFsb256byA8am1hbG9uem9AZ21haWwuY29tPgorICog Q29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YSA8Z25zQGdub21lLm9yZz4K ICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtNjEwLDkgKzYxMSw3IEBAIGdjaGFyKiB3ZWJraXRfd2Vi X2ZyYW1lX2R1bXBfcmVuZGVyX3RyZWUoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogICAgIHJldHVy biBnX3N0cmR1cChzdHJpbmcudXRmOCgpLmRhdGEoKSk7CiB9CiAKLSNpZiBHVEtfQ0hFQ0tfVkVS U0lPTigyLDEwLDApCi0KLXN0YXRpYyB2b2lkIGJlZ2luX3ByaW50KEd0a1ByaW50T3BlcmF0aW9u KiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCitzdGF0 aWMgdm9pZCBiZWdpblByaW50Q2FsbGJhY2soR3RrUHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmlu dENvbnRleHQqIGNvbnRleHQsIGdwb2ludGVyIHVzZXJfZGF0YSkKIHsKICAgICBQcmludENvbnRl eHQqIHByaW50Q29udGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UHJpbnRDb250ZXh0Kj4odXNlcl9k YXRhKTsKIApAQCAtNjMwLDcgKzYyOSw3IEBAIHN0YXRpYyB2b2lkIGJlZ2luX3ByaW50KEd0a1By aW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlCiAgICAg Z3RrX3ByaW50X29wZXJhdGlvbl9zZXRfbl9wYWdlcyhvcCwgcHJpbnRDb250ZXh0LT5wYWdlQ291 bnQoKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGRyYXdfcGFnZShHdGtQcmludE9wZXJhdGlvbiogb3As IEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ2ludCBwYWdlX25yLCBncG9pbnRlciB1c2VyX2Rh dGEpCitzdGF0aWMgdm9pZCBkcmF3UGFnZUNhbGxiYWNrKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwg R3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2VfbnIsIGdwb2ludGVyIHVzZXJfZGF0 YSkKIHsKICAgICBQcmludENvbnRleHQqIHByaW50Q29udGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8 UHJpbnRDb250ZXh0Kj4odXNlcl9kYXRhKTsKIApAQCAtNjQwLDEzICs2MzksMjMgQEAgc3RhdGlj IHZvaWQgZHJhd19wYWdlKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBj b250ZXh0LCBnaW50IHBhZ2UKICAgICBwcmludENvbnRleHQtPnNwb29sUGFnZShjdHgsIHBhZ2Vf bnIsIHdpZHRoKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX3ByaW50KEd0a1ByaW50T3BlcmF0aW9u KiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCitzdGF0 aWMgdm9pZCBlbmRQcmludENhbGxiYWNrKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRD b250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCiB7CiAgICAgUHJpbnRDb250ZXh0 KiBwcmludENvbnRleHQgPSByZWludGVycHJldF9jYXN0PFByaW50Q29udGV4dCo+KHVzZXJfZGF0 YSk7CiAgICAgcHJpbnRDb250ZXh0LT5lbmQoKTsKIH0KIAotdm9pZCB3ZWJraXRfd2ViX2ZyYW1l X3ByaW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKKy8qKgorICogd2Via2l0X3dlYl9mcmFtZV9w cmludDoKKyAqIEBmcmFtZTogYSAjV2ViS2l0V2ViRnJhbWUKKyAqIEBvcGVyYXRpb246IHRoZSAj R3RrUHJpbnRPcGVyYXRpb24gdG8gYmUgY2FycmllZAorICogQGVycm9yOiAjR0Vycm9yIGZvciBl cnJvciByZXR1cm4KKyAqCisgKiBQcmludHMgdGhlIGdpdmVuICNXZWJLaXRGcmFtZSwgdXNpbmcg dGhlIGdpdmVuICNHdGtQcmludE9wZXJhdGlvbi4KKyAqCisgKiBTaW5jZTogMS4xLjQKKyAqLwor R3RrUHJpbnRPcGVyYXRpb25SZXN1bHQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJG cmFtZSogZnJhbWUsIEd0a1ByaW50T3BlcmF0aW9uKiBvcGVyYXRpb24sIEd0a1ByaW50T3BlcmF0 aW9uQWN0aW9uIGFjdGlvbiwgR0Vycm9yKiogZXJyb3IpCiB7CiAgICAgR3RrV2lkZ2V0KiB0b3BM ZXZlbCA9IGd0a193aWRnZXRfZ2V0X3RvcGxldmVsKEdUS19XSURHRVQod2Via2l0X3dlYl9mcmFt ZV9nZXRfd2ViX3ZpZXcoZnJhbWUpKSk7CiAgICAgaWYgKCFHVEtfV0lER0VUX1RPUExFVkVMKHRv cExldmVsKSkKQEAgLTY1NCw0MCArNjYzLDE3IEBAIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmlu dChXZWJLaXRXZWJGcmFtZSogZnJhbWUpCiAKICAgICBGcmFtZSogY29yZUZyYW1lID0gY29yZShm cmFtZSk7CiAgICAgaWYgKCFjb3JlRnJhbWUpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0 dXJuIEdUS19QUklOVF9PUEVSQVRJT05fUkVTVUxUX0NBTkNFTDsKIAogICAgIFByaW50Q29udGV4 dCBwcmludENvbnRleHQoY29yZUZyYW1lKTsKIAotICAgIEd0a1ByaW50T3BlcmF0aW9uKiBvcCA9 IGd0a19wcmludF9vcGVyYXRpb25fbmV3KCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChvcCwgImJl Z2luLXByaW50IiwgR19DQUxMQkFDSyhiZWdpbl9wcmludCksICZwcmludENvbnRleHQpOwotICAg IGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJkcmF3LXBhZ2UiLCBHX0NBTExCQUNLKGRyYXdfcGFnZSks ICZwcmludENvbnRleHQpOwotICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJlbmQtcHJpbnQiLCBH X0NBTExCQUNLKGVuZF9wcmludCksICZwcmludENvbnRleHQpOwotICAgIEdFcnJvciAqZXJyb3Ig PSBOVUxMOwotICAgIGd0a19wcmludF9vcGVyYXRpb25fcnVuKG9wLCBHVEtfUFJJTlRfT1BFUkFU SU9OX0FDVElPTl9QUklOVF9ESUFMT0csIEdUS19XSU5ET1codG9wTGV2ZWwpLCAmZXJyb3IpOwot ICAgIGdfb2JqZWN0X3VucmVmKG9wKTsKLQotICAgIGlmIChlcnJvcikgewotICAgICAgICBHdGtX aWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxvZ19uZXcoR1RLX1dJTkRPVyh0b3BMZXZl bCksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBH VEtfRElBTE9HX0RFU1RST1lfV0lUSF9QQVJFTlQsCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfTUVTU0FHRV9FUlJPUiwKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NF LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiVz IiwgZXJyb3ItPm1lc3NhZ2UpOwotICAgICAgICBnX2Vycm9yX2ZyZWUoZXJyb3IpOwotCi0gICAg ICAgIGdfc2lnbmFsX2Nvbm5lY3QoZGlhbG9nLCAicmVzcG9uc2UiLCBHX0NBTExCQUNLKGd0a193 aWRnZXRfZGVzdHJveSksIE5VTEwpOwotICAgICAgICBndGtfd2lkZ2V0X3Nob3coZGlhbG9nKTsK LSAgICB9Ci19Ci0KLSNlbHNlCisgICAgZ19zaWduYWxfY29ubmVjdChvcGVyYXRpb24sICJiZWdp bi1wcmludCIsIEdfQ0FMTEJBQ0soYmVnaW5QcmludENhbGxiYWNrKSwgJnByaW50Q29udGV4dCk7 CisgICAgZ19zaWduYWxfY29ubmVjdChvcGVyYXRpb24sICJkcmF3LXBhZ2UiLCBHX0NBTExCQUNL KGRyYXdQYWdlQ2FsbGJhY2spLCAmcHJpbnRDb250ZXh0KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0 KG9wZXJhdGlvbiwgImVuZC1wcmludCIsIEdfQ0FMTEJBQ0soZW5kUHJpbnRDYWxsYmFjayksICZw cmludENvbnRleHQpOwogCi12b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJh bWUqKQotewotICAgIGdfd2FybmluZygiUHJpbnRpbmcgc3VwcG9ydCBpcyBub3QgYXZhaWxhYmxl IGluIG9sZGVyIHZlcnNpb25zIG9mIEdUSysiKTsKKyAgICByZXR1cm4gZ3RrX3ByaW50X29wZXJh dGlvbl9ydW4ob3BlcmF0aW9uLCBhY3Rpb24sIEdUS19XSU5ET1codG9wTGV2ZWwpLCBlcnJvcik7 CiB9CiAKLSNlbmRpZgotCiBib29sIHdlYmtpdF93ZWJfZnJhbWVfcGF1c2VfYW5pbWF0aW9uKFdl YktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIG5hbWUsIGRvdWJsZSB0aW1lLCBjb25z dCBnY2hhciogZWxlbWVudCkKIHsKICAgICBBU1NFUlQoY29yZShmcmFtZSkpOwpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaCBiL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHdlYmZyYW1lLmgKaW5kZXggN2UyNDU2NS4uODM3ZDQyZSAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXR3ZWJmcmFtZS5oCkBAIC0yMiw2ICsyMiw4IEBACiAjZGVmaW5lIFdFQktJVF9XRUJfRlJB TUVfSAogCiAjaW5jbHVkZSA8Z2xpYi1vYmplY3QuaD4KKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisK ICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU0Jhc2UuaD4KIAogI2luY2x1ZGUgPHdlYmtpdC93 ZWJraXRkZWZpbmVzLmg+CkBAIC0xMDgsNiArMTEwLDEyIEBAIHdlYmtpdF93ZWJfZnJhbWVfZmlu ZF9mcmFtZSAgICAgICAgIChXZWJLaXRXZWJGcmFtZSAgICAgICAqZnJhbWUsCiBXRUJLSVRfQVBJ IEpTR2xvYmFsQ29udGV4dFJlZgogd2Via2l0X3dlYl9mcmFtZV9nZXRfZ2xvYmFsX2NvbnRleHQg KFdlYktpdFdlYkZyYW1lICAgICAgICpmcmFtZSk7CiAKK1dFQktJVF9BUEkgR3RrUHJpbnRPcGVy YXRpb25SZXN1bHQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnQgICAgICAgICAgICAgIChXZWJLaXRX ZWJGcmFtZSAgICAgICAqZnJhbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgR3RrUHJpbnRPcGVyYXRpb24gICAgKm9wZXJhdGlvbiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBHdGtQcmludE9wZXJhdGlvbkFjdGlvbiBhY3Rpb24sCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0Vycm9yICAgICAgICAgICAgICAqKmVycm9y KTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw CmluZGV4IDEyOWRkNTEuLjc3NTdkZWYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw CkBAIC0xMzYsNiArMTM2LDcgQEAgZW51bSB7CiAgICAgUEFTVEVfQ0xJUEJPQVJELAogICAgIENV VF9DTElQQk9BUkQsCiAgICAgRE9XTkxPQURfUkVRVUVTVEVELAorICAgIFBSSU5UX1JFUVVFU1RF RCwKICAgICBMQVNUX1NJR05BTAogfTsKIApAQCAtMTI4NSw2ICsxMjg2LDI5IEBAIHN0YXRpYyB2 b2lkIHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KFdlYktpdFdlYlZpZXdDbGFzcyogd2ViVmll d0NsYXNzKQogICAgICAgICAgICAgR19UWVBFX05PTkUsIDEsCiAgICAgICAgICAgICBHVEtfVFlQ RV9NRU5VKTsKIAorICAgIC8qKgorICAgICAqIFdlYktpdFdlYkZyYW1lOjpwcmludC1yZXF1ZXN0 ZWQKKyAgICAgKiBAd2ViX3ZpZXc6IHRoZSBvYmplY3QgaW4gd2hpY2ggdGhlIHNpZ25hbCBpcyBl bWl0dGVkCisgICAgICogQHdlYl9mcmFtZTogdGhlIGZyYW1lIHRoYXQgaXMgcmVxdWVzdGluZyB0 byBiZSBwcmludGVkCisgICAgICogQHJldHVybjogJVRSVUUgaWYgdGhlIHByaW50IHJlcXVlc3Qg aGFzIGJlZW4gaGFuZGxlZCwgJUZBTFNFIGlmCisgICAgICogdGhlIGRlZmF1bHQgaGFuZGxlciBz aG91bGQgcnVuCisgICAgICoKKyAgICAgKiBFbWl0dGVkIHdoZW4gcHJpbnRpbmcgaXMgcmVxdWVz dGVkIGJ5IHRoZSBmcmFtZSwgdXN1YWxseQorICAgICAqIGJlY2F1c2Ugb2YgYSBqYXZhc2NyaXB0 IGNhbGwuIFRoZSBkZWZhdWx0IGhhbmRsZXIgd2lsbCBwcmVzZW50CisgICAgICogYSBwcmludCBk aWFsb2cgYW5kIGNhcnJ5IGEgcHJpbnQgb3BlcmF0aW9uLiBOb3RpY2UgdGhhdCB0aGlzCisgICAg ICogbWVhbnMgdGhhdCBpZiB5b3UgaW50ZW5kIHRvIGlnbm9yZSBhIHByaW50IHJlcXVlc3QgeW91 IG11c3QKKyAgICAgKiBjb25uZWN0IHRvIHRoaXMgc2lnbmFsLCBhbmQgcmV0dXJuICVUUlVFLgor ICAgICAqLworICAgIHdlYmtpdF93ZWJfdmlld19zaWduYWxzW1BSSU5UX1JFUVVFU1RFRF0gPSBn X3NpZ25hbF9uZXcoInByaW50LXJlcXVlc3RlZCIsCisgICAgICAgICAgICBHX1RZUEVfRlJPTV9D TEFTUyh3ZWJWaWV3Q2xhc3MpLAorICAgICAgICAgICAgKEdTaWduYWxGbGFncykoR19TSUdOQUxf UlVOX0xBU1QgfCBHX1NJR05BTF9BQ1RJT04pLAorICAgICAgICAgICAgMCwKKyAgICAgICAgICAg IE5VTEwsCisgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgd2Via2l0X21hcnNoYWxfQk9P TEVBTl9fT0JKRUNULAorICAgICAgICAgICAgR19UWVBFX0JPT0xFQU4sIDEsCisgICAgICAgICAg ICBXRUJLSVRfVFlQRV9XRUJfRlJBTUUpOworCiAgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNb U1RBVFVTX0JBUl9URVhUX0NIQU5HRURdID0gZ19zaWduYWxfbmV3KCJzdGF0dXMtYmFyLXRleHQt Y2hhbmdlZCIsCiAgICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyh3ZWJWaWV3Q2xhc3MpLAog ICAgICAgICAgICAgKEdTaWduYWxGbGFncykoR19TSUdOQUxfUlVOX0xBU1QgfCBHX1NJR05BTF9B Q1RJT04pLAotLSAKMS42LjIuMQoK 28860 2009-03-23 12:24:54 -0700 2009-03-31 09:34:04 -0700 proposed API printing.patch text/plain 11318 gustavo RnJvbSBjZjhiZGE5NmY3Y2I1Y2Q4NjYyN2MwYmNlNjMxMmVlNzRiMGFjODRlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBNb24sIDIzIE1hciAyMDA5IDE2OjEyOjQ2IC0wMzAwClN1YmplY3Q6IFtQQVRDSF0g MjAwOS0wMy0yMyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KCiAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjg5OAogICAgICAgIFtHVEtdIG5lZWQgcHJvcGVyIEFQ SSBmb3IgcHJpbnRpbmcKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciBwcmludGluZyBBUEksIHVz aW5nIHRoZSBHVEsrIHByaW50aW5nIEFQSS4KCiAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9DaHJv bWVDbGllbnRHdGsuY3BwOgogICAgICAgIChXZWJLaXQ6OkNocm9tZUNsaWVudDo6cHJpbnQpOgog ICAgICAgICogd2Via2l0L3dlYmtpdHByaXZhdGUuaDoKICAgICAgICAqIHdlYmtpdC93ZWJraXR3 ZWJmcmFtZS5jcHA6CiAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuaDoKICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKLS0tCiBXZWJLaXQvZ3RrL0NoYW5nZUxvZyAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKysKIFdlYktpdC9ndGsvV2ViQ29yZVN1 cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcCB8ICAgMjYgKysrKysrKysrKystCiBXZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgfCAgICAzIC0KIFdlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCAgICAgICAgICB8ICAgNTggKysrKysrKysrKy0tLS0t LS0tLS0tLS0tCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oICAgICAgICAgICAg fCAgICA4ICsrKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgICAgICAgICAg IHwgICAyOSArKysrKysrKysrKysKIDYgZmlsZXMgY2hhbmdlZCwgMTAyIGluc2VydGlvbnMoKyks IDM4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggNzlhNzM0ZS4uY2I3MTFlYyAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx OSBAQAorMjAwOS0wMy0yMyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4OTgKKyAgICAgICAgW0dUS10gbmVl ZCBwcm9wZXIgQVBJIGZvciBwcmludGluZworCisgICAgICAgIEltcGxlbWVudCBwcm9wZXIgcHJp bnRpbmcgQVBJLCB1c2luZyB0aGUgR1RLKyBwcmludGluZyBBUEkuCisKKyAgICAgICAgKiBXZWJD b3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwOgorICAgICAgICAoV2ViS2l0OjpDaHJvbWVD bGllbnQ6OnByaW50KToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAg ICAqIHdlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHA6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdl YmZyYW1lLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorCiAyMDA5LTAz LTIwICBKYW4gTWljaGFlbCBBbG9uem8gIDxqbWFsb256b0BnbWFpbC5jb20+CiAKICAgICAgICAg Tm90IHJldmlld2VkLiBGaXggc3R5bGUgaXNzdWVzIHdpdGggbXkgcHJldmlvdXMgY29tbWl0IChy NDE4NjYpIGFzCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNs aWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5j cHAKaW5kZXggMzU1N2EzZi4uZjA5MzcxYiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3Jl U3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwCisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBv cnQvQ2hyb21lQ2xpZW50R3RrLmNwcApAQCAtMzkwLDcgKzM5MCwzMSBAQCB2b2lkIENocm9tZUNs aWVudDo6c2V0VG9vbFRpcChjb25zdCBTdHJpbmcmIHRvb2xUaXApCiAKIHZvaWQgQ2hyb21lQ2xp ZW50OjpwcmludChGcmFtZSogZnJhbWUpCiB7Ci0gICAgd2Via2l0X3dlYl9mcmFtZV9wcmludChr aXQoZnJhbWUpKTsKKyAgICBXZWJLaXRXZWJGcmFtZSogd2ViRnJhbWUgPSBraXQoZnJhbWUpOwor ICAgIGdib29sZWFuIGlzSGFuZGxlZCA9IGZhbHNlOworICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFt ZShtX3dlYlZpZXcsICJwcmludC1yZXF1ZXN0ZWQiLCB3ZWJGcmFtZSwgJmlzSGFuZGxlZCk7CisK KyAgICBpZiAoaXNIYW5kbGVkKQorICAgICAgICByZXR1cm47CisKKyAgICBHdGtQcmludE9wZXJh dGlvbiogb3BlcmF0aW9uID0gZ3RrX3ByaW50X29wZXJhdGlvbl9uZXcoKTsKKyAgICBHRXJyb3Iq IGVycm9yID0gMDsKKworICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQod2ViRnJhbWUsIG9wZXJh dGlvbiwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fUFJJTlRfRElBTE9HLCAmZXJyb3IpOwor ICAgIGdfb2JqZWN0X3VucmVmKG9wZXJhdGlvbik7CisKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAg ICAgR3RrV2lkZ2V0KiB3aW5kb3cgPSBndGtfd2lkZ2V0X2dldF90b3BsZXZlbChHVEtfV0lER0VU KG1fd2ViVmlldykpOworICAgICAgICBHdGtXaWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2Rp YWxvZ19uZXcoR1RLX1dJREdFVF9UT1BMRVZFTCh3aW5kb3cpID8gR1RLX1dJTkRPVyh3aW5kb3cp IDogMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEdUS19ESUFMT0dfREVTVFJPWV9XSVRIX1BBUkVOVCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19NRVNTQUdFX0VSUk9SLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX0JVVFRPTlNfQ0xP U0UsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi JXMiLCBlcnJvci0+bWVzc2FnZSk7CisgICAgICAgIGdfZXJyb3JfZnJlZShlcnJvcik7CisKKyAg ICAgICAgZ19zaWduYWxfY29ubmVjdChkaWFsb2csICJyZXNwb25zZSIsIEdfQ0FMTEJBQ0soZ3Rr X3dpZGdldF9kZXN0cm95KSwgMCk7CisgICAgICAgIGd0a193aWRnZXRfc2hvdyhkaWFsb2cpOwor ICAgIH0KIH0KIAogdm9pZCBDaHJvbWVDbGllbnQ6OmV4Y2VlZGVkRGF0YWJhc2VRdW90YShGcmFt ZSogZnJhbWUsIGNvbnN0IFN0cmluZyYpCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXgg MGI4M2ExMS4uODIzMGI4NiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMTc2LDkg KzE3Niw2IEBAIGV4dGVybiAiQyIgewogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAgICAgd2Via2l0 X3dlYl9mcmFtZV9nZXRfaW5uZXJfdGV4dCAoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKIAotICAg IFdFQktJVF9BUEkgdm9pZAotICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQgKFdlYktpdFdlYkZy YW1lKiBmcmFtZSk7Ci0KICAgICBXRUJLSVRfQVBJIGdjaGFyKgogICAgIHdlYmtpdF93ZWJfZnJh bWVfZHVtcF9yZW5kZXJfdHJlZSAoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKIApkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2ViZnJhbWUuY3BwCmluZGV4IGUyYjEwYjYuLmQ1MjE5MDUgMTAwNjQ0Ci0tLSBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKQEAgLTYsNiArNiw3IEBACiAgKiBDb3B5cmlnaHQgKEMp IDIwMDggQ29sbGFib3JhIEx0ZC4KICAqIENvcHlyaWdodCAoQykgMjAwOCBOdWFudGkgTHRkLgog ICogQ29weXJpZ2h0IChDKSAyMDA5IEphbiBBbG9uem8gPGptYWxvbnpvQGdtYWlsLmNvbT4KKyAq IENvcHlyaWdodCAoQykgMjAwOSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGduc0Bnbm9tZS5vcmc+ CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExp YnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTYxMCw5ICs2MTEsNyBAQCBnY2hhciogd2Via2l0X3dl Yl9mcmFtZV9kdW1wX3JlbmRlcl90cmVlKFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKICAgICByZXR1 cm4gZ19zdHJkdXAoc3RyaW5nLnV0ZjgoKS5kYXRhKCkpOwogfQogCi0jaWYgR1RLX0NIRUNLX1ZF UlNJT04oMiwxMCwwKQotCi1zdGF0aWMgdm9pZCBiZWdpbl9wcmludChHdGtQcmludE9wZXJhdGlv biogb3AsIEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ3BvaW50ZXIgdXNlcl9kYXRhKQorc3Rh dGljIHZvaWQgYmVnaW5QcmludENhbGxiYWNrKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJp bnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCiB7CiAgICAgUHJpbnRDb250 ZXh0KiBwcmludENvbnRleHQgPSByZWludGVycHJldF9jYXN0PFByaW50Q29udGV4dCo+KHVzZXJf ZGF0YSk7CiAKQEAgLTYzMCw3ICs2MjksNyBAQCBzdGF0aWMgdm9pZCBiZWdpbl9wcmludChHdGtQ cmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ3BvaW50ZQogICAg IGd0a19wcmludF9vcGVyYXRpb25fc2V0X25fcGFnZXMob3AsIHByaW50Q29udGV4dC0+cGFnZUNv dW50KCkpOwogfQogCi1zdGF0aWMgdm9pZCBkcmF3X3BhZ2UoR3RrUHJpbnRPcGVyYXRpb24qIG9w LCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdpbnQgcGFnZV9uciwgZ3BvaW50ZXIgdXNlcl9k YXRhKQorc3RhdGljIHZvaWQgZHJhd1BhZ2VDYWxsYmFjayhHdGtQcmludE9wZXJhdGlvbiogb3As IEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ2ludCBwYWdlX25yLCBncG9pbnRlciB1c2VyX2Rh dGEpCiB7CiAgICAgUHJpbnRDb250ZXh0KiBwcmludENvbnRleHQgPSByZWludGVycHJldF9jYXN0 PFByaW50Q29udGV4dCo+KHVzZXJfZGF0YSk7CiAKQEAgLTY0MCwxMyArNjM5LDI3IEBAIHN0YXRp YyB2b2lkIGRyYXdfcGFnZShHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29udGV4dCog Y29udGV4dCwgZ2ludCBwYWdlCiAgICAgcHJpbnRDb250ZXh0LT5zcG9vbFBhZ2UoY3R4LCBwYWdl X25yLCB3aWR0aCk7CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9wcmludChHdGtQcmludE9wZXJhdGlv biogb3AsIEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ3BvaW50ZXIgdXNlcl9kYXRhKQorc3Rh dGljIHZvaWQgZW5kUHJpbnRDYWxsYmFjayhHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50 Q29udGV4dCogY29udGV4dCwgZ3BvaW50ZXIgdXNlcl9kYXRhKQogewogICAgIFByaW50Q29udGV4 dCogcHJpbnRDb250ZXh0ID0gcmVpbnRlcnByZXRfY2FzdDxQcmludENvbnRleHQqPih1c2VyX2Rh dGEpOwogICAgIHByaW50Q29udGV4dC0+ZW5kKCk7CiB9CiAKLXZvaWQgd2Via2l0X3dlYl9mcmFt ZV9wcmludChXZWJLaXRXZWJGcmFtZSogZnJhbWUpCisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVf cHJpbnQ6CisgKiBAZnJhbWU6IGEgI1dlYktpdFdlYkZyYW1lCisgKiBAb3BlcmF0aW9uOiB0aGUg I0d0a1ByaW50T3BlcmF0aW9uIHRvIGJlIGNhcnJpZWQKKyAqIEBhY3Rpb246IHRoZSAjR3RrUHJp bnRPcGVyYXRpb25BY3Rpb24gdG8gYmUgcGVyZm9ybWVkCisgKiBAZXJyb3I6ICNHRXJyb3IgZm9y IGVycm9yIHJldHVybgorICoKKyAqIFByaW50cyB0aGUgZ2l2ZW4gI1dlYktpdEZyYW1lLCB1c2lu ZyB0aGUgZ2l2ZW4gI0d0a1ByaW50T3BlcmF0aW9uCisgKiBhbmQgI0d0a1ByaW50T3BlcmF0aW9u QWN0aW9uLiBUaGlzIGZ1bmN0aW9uIHdyYXBzIGEgY2FsbCB0bworICogZ3RrX3ByaW50X29wZXJh dGlvbl9ydW4oKSBmb3IgcHJpbnRpbmcgdGhlIGNvbnRlbnRzIG9mIHRoZQorICogI1dlYktpdFdl YkZyYW1lLgorICoKKyAqIFNpbmNlOiAxLjEuNAorICovCitHdGtQcmludE9wZXJhdGlvblJlc3Vs dCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgR3RrUHJpbnRP cGVyYXRpb24qIG9wZXJhdGlvbiwgR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gYWN0aW9uLCBHRXJy b3IqKiBlcnJvcikKIHsKICAgICBHdGtXaWRnZXQqIHRvcExldmVsID0gZ3RrX3dpZGdldF9nZXRf dG9wbGV2ZWwoR1RLX1dJREdFVCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhmcmFtZSkp KTsKICAgICBpZiAoIUdUS19XSURHRVRfVE9QTEVWRUwodG9wTGV2ZWwpKQpAQCAtNjU0LDQwICs2 NjcsMTcgQEAgdm9pZCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50KFdlYktpdFdlYkZyYW1lKiBmcmFt ZSkKIAogICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKICAgICBpZiAoIWNvcmVG cmFtZSkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1cm4gR1RLX1BSSU5UX09QRVJBVElP Tl9SRVNVTFRfQ0FOQ0VMOwogCiAgICAgUHJpbnRDb250ZXh0IHByaW50Q29udGV4dChjb3JlRnJh bWUpOwogCi0gICAgR3RrUHJpbnRPcGVyYXRpb24qIG9wID0gZ3RrX3ByaW50X29wZXJhdGlvbl9u ZXcoKTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiYmVnaW4tcHJpbnQiLCBHX0NBTExCQUNL KGJlZ2luX3ByaW50KSwgJnByaW50Q29udGV4dCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChvcCwg ImRyYXctcGFnZSIsIEdfQ0FMTEJBQ0soZHJhd19wYWdlKSwgJnByaW50Q29udGV4dCk7Ci0gICAg Z19zaWduYWxfY29ubmVjdChvcCwgImVuZC1wcmludCIsIEdfQ0FMTEJBQ0soZW5kX3ByaW50KSwg JnByaW50Q29udGV4dCk7Ci0gICAgR0Vycm9yICplcnJvciA9IE5VTEw7Ci0gICAgZ3RrX3ByaW50 X29wZXJhdGlvbl9ydW4ob3AsIEdUS19QUklOVF9PUEVSQVRJT05fQUNUSU9OX1BSSU5UX0RJQUxP RywgR1RLX1dJTkRPVyh0b3BMZXZlbCksICZlcnJvcik7Ci0gICAgZ19vYmplY3RfdW5yZWYob3Ap OwotCi0gICAgaWYgKGVycm9yKSB7Ci0gICAgICAgIEd0a1dpZGdldCogZGlhbG9nID0gZ3RrX21l c3NhZ2VfZGlhbG9nX25ldyhHVEtfV0lORE9XKHRvcExldmVsKSwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19ESUFMT0dfREVTVFJPWV9XSVRI X1BBUkVOVCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIEdUS19NRVNTQUdFX0VSUk9SLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgR1RLX0JVVFRPTlNfQ0xPU0UsCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiJXMiLCBlcnJvci0+bWVzc2FnZSk7Ci0g ICAgICAgIGdfZXJyb3JfZnJlZShlcnJvcik7Ci0KLSAgICAgICAgZ19zaWduYWxfY29ubmVjdChk aWFsb2csICJyZXNwb25zZSIsIEdfQ0FMTEJBQ0soZ3RrX3dpZGdldF9kZXN0cm95KSwgTlVMTCk7 Ci0gICAgICAgIGd0a193aWRnZXRfc2hvdyhkaWFsb2cpOwotICAgIH0KLX0KLQotI2Vsc2UKKyAg ICBnX3NpZ25hbF9jb25uZWN0KG9wZXJhdGlvbiwgImJlZ2luLXByaW50IiwgR19DQUxMQkFDSyhi ZWdpblByaW50Q2FsbGJhY2spLCAmcHJpbnRDb250ZXh0KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0 KG9wZXJhdGlvbiwgImRyYXctcGFnZSIsIEdfQ0FMTEJBQ0soZHJhd1BhZ2VDYWxsYmFjayksICZw cmludENvbnRleHQpOworICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3BlcmF0aW9uLCAiZW5kLXByaW50 IiwgR19DQUxMQkFDSyhlbmRQcmludENhbGxiYWNrKSwgJnByaW50Q29udGV4dCk7CiAKLXZvaWQg d2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSopCi17Ci0gICAgZ193YXJuaW5n KCJQcmludGluZyBzdXBwb3J0IGlzIG5vdCBhdmFpbGFibGUgaW4gb2xkZXIgdmVyc2lvbnMgb2Yg R1RLKyIpOworICAgIHJldHVybiBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bihvcGVyYXRpb24sIGFj dGlvbiwgR1RLX1dJTkRPVyh0b3BMZXZlbCksIGVycm9yKTsKIH0KIAotI2VuZGlmCi0KIGJvb2wg d2Via2l0X3dlYl9mcmFtZV9wYXVzZV9hbmltYXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBj b25zdCBnY2hhciogbmFtZSwgZG91YmxlIHRpbWUsIGNvbnN0IGdjaGFyKiBlbGVtZW50KQogewog ICAgIEFTU0VSVChjb3JlKGZyYW1lKSk7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXR3ZWJmcmFtZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAppbmRl eCA3ZTI0NTY1Li44MzdkNDJlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJmcmFtZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgKQEAgLTIy LDYgKzIyLDggQEAKICNkZWZpbmUgV0VCS0lUX1dFQl9GUkFNRV9ICiAKICNpbmNsdWRlIDxnbGli LW9iamVjdC5oPgorI2luY2x1ZGUgPGd0ay9ndGsuaD4KKwogI2luY2x1ZGUgPEphdmFTY3JpcHRD b3JlL0pTQmFzZS5oPgogCiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KQEAgLTEw OCw2ICsxMTAsMTIgQEAgd2Via2l0X3dlYl9mcmFtZV9maW5kX2ZyYW1lICAgICAgICAgKFdlYktp dFdlYkZyYW1lICAgICAgICpmcmFtZSwKIFdFQktJVF9BUEkgSlNHbG9iYWxDb250ZXh0UmVmCiB3 ZWJraXRfd2ViX2ZyYW1lX2dldF9nbG9iYWxfY29udGV4dCAoV2ViS2l0V2ViRnJhbWUgICAgICAg KmZyYW1lKTsKIAorV0VCS0lUX0FQSSBHdGtQcmludE9wZXJhdGlvblJlc3VsdAord2Via2l0X3dl Yl9mcmFtZV9wcmludCAgICAgICAgICAgICAgKFdlYktpdFdlYkZyYW1lICAgICAgICpmcmFtZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHdGtQcmludE9wZXJhdGlvbiAg ICAqb3BlcmF0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1By aW50T3BlcmF0aW9uQWN0aW9uIGFjdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBHRXJyb3IgICAgICAgICAgICAgICoqZXJyb3IpOworCiBHX0VORF9ERUNMUwogCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKaW5kZXggMTI5ZGQ1MS4uZjNiZmIx OSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKKysrIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKQEAgLTEzNiw2ICsxMzYsNyBAQCBl bnVtIHsKICAgICBQQVNURV9DTElQQk9BUkQsCiAgICAgQ1VUX0NMSVBCT0FSRCwKICAgICBET1dO TE9BRF9SRVFVRVNURUQsCisgICAgUFJJTlRfUkVRVUVTVEVELAogICAgIExBU1RfU0lHTkFMCiB9 OwogCkBAIC0xMjg1LDYgKzEyODYsMzQgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2Ns YXNzX2luaXQoV2ViS2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAgICBH X1RZUEVfTk9ORSwgMSwKICAgICAgICAgICAgIEdUS19UWVBFX01FTlUpOwogCisgICAgLyoqCisg ICAgICogV2ViS2l0V2ViVmlldzo6cHJpbnQtcmVxdWVzdGVkCisgICAgICogQHdlYl92aWV3OiB0 aGUgb2JqZWN0IGluIHdoaWNoIHRoZSBzaWduYWwgaXMgZW1pdHRlZAorICAgICAqIEB3ZWJfZnJh bWU6IHRoZSBmcmFtZSB0aGF0IGlzIHJlcXVlc3RpbmcgdG8gYmUgcHJpbnRlZAorICAgICAqIEBy ZXR1cm46ICVUUlVFIGlmIHRoZSBwcmludCByZXF1ZXN0IGhhcyBiZWVuIGhhbmRsZWQsICVGQUxT RSBpZgorICAgICAqIHRoZSBkZWZhdWx0IGhhbmRsZXIgc2hvdWxkIHJ1bgorICAgICAqCisgICAg ICogRW1pdHRlZCB3aGVuIHByaW50aW5nIGlzIHJlcXVlc3RlZCBieSB0aGUgZnJhbWUsIHVzdWFs bHkKKyAgICAgKiBiZWNhdXNlIG9mIGEgamF2YXNjcmlwdCBjYWxsLiBXaGlsZSBoYW5kbGluZyB0 aGlzIHNpZ25hbCB5b3UKKyAgICAgKiBzaG91bGQgY2FsbCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50 KCkgdG8gZG8gdGhlIGFjdHVhbCBwcmludGluZy4KKyAgICAgKgorICAgICAqIFRoZSBkZWZhdWx0 IGhhbmRsZXIgd2lsbCBwcmVzZW50IGEgcHJpbnQgZGlhbG9nIGFuZCBjYXJyeSBhCisgICAgICog cHJpbnQgb3BlcmF0aW9uLiBOb3RpY2UgdGhhdCB0aGlzIG1lYW5zIHRoYXQgaWYgeW91IGludGVu ZCB0bworICAgICAqIGlnbm9yZSBhIHByaW50IHJlcXVlc3QgeW91IG11c3QgY29ubmVjdCB0byB0 aGlzIHNpZ25hbCwgYW5kCisgICAgICogcmV0dXJuICVUUlVFLgorICAgICAqCisgICAgICogU2lu Y2U6IDEuMS40CisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNbUFJJTlRfUkVR VUVTVEVEXSA9IGdfc2lnbmFsX25ldygicHJpbnQtcmVxdWVzdGVkIiwKKyAgICAgICAgICAgIEdf VFlQRV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCisgICAgICAgICAgICAoR1NpZ25hbEZsYWdz KShHX1NJR05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCisgICAgICAgICAgICAwLAor ICAgICAgICAgICAgTlVMTCwKKyAgICAgICAgICAgIE5VTEwsCisgICAgICAgICAgICB3ZWJraXRf bWFyc2hhbF9CT09MRUFOX19PQkpFQ1QsCisgICAgICAgICAgICBHX1RZUEVfQk9PTEVBTiwgMSwK KyAgICAgICAgICAgIFdFQktJVF9UWVBFX1dFQl9GUkFNRSk7CisKICAgICB3ZWJraXRfd2ViX3Zp ZXdfc2lnbmFsc1tTVEFUVVNfQkFSX1RFWFRfQ0hBTkdFRF0gPSBnX3NpZ25hbF9uZXcoInN0YXR1 cy1iYXItdGV4dC1jaGFuZ2VkIiwKICAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdlYlZp ZXdDbGFzcyksCiAgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFTVCB8 IEdfU0lHTkFMX0FDVElPTiksCi0tIAoxLjYuMi4xCgo= 29054 2009-03-30 01:37:18 -0700 2009-03-30 01:39:28 -0700 API usage example example.c text/x-csrc 1614 colin LyogQ2FsbGVyIGFwcCBleHBvcnRzIHRvIGZpbGUgYnkgaXRzZWxmICovCnZvaWQgZXhwb3J0X3Bh Z2UoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBHdGtQcmludFNldHRpbmdzICpwcmludF9zZXR0aW5n cykKewoJR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRpb25f bmV3KCk7CglHRXJyb3IgKmVycm9yID0gTlVMTDsKCWd0a19wcmludF9vcGVyYXRpb25fc2V0X2V4 cG9ydF9maWxlbmFtZShvcGVyYXRpb24sIGZpbGVuYW1lKTsKCWd0a19wcmludF9vcGVyYXRpb25f c2V0X3ByaW50X3NldHRpbmdzKG9wZXJhdGlvbiwgcHJpbnRfc2V0dGluZ3MpOwoKCXdlYmtpdF93 ZWJfZnJhbWVfcHJpbnQoZnJhbWUsIG9wZXJhdGlvbiwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJ T05fRVhQT1JULCAmZXJyb3IpOwoJaWYgKGVycm9yKQoJCWdfZXJyb3JfZnJlZShlcnJvcik7CgoJ Z19vYmplY3RfdW5yZWYob3BlcmF0aW9uKTsKfQoKLyogQ2FsbGVyIGFwcCBwcmludHMgYnkgaXRz ZWxmIChGaWxlL1ByaW50IGZvciBleGFtcGxlKSAqLwp2b2lkIHByaW50X2RpYWxvZ19mcmFtZShX ZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50U2V0dGluZ3MgKipwcmludF9zZXR0aW5ncykK ewoJR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRpb25fbmV3 KCk7CglHRXJyb3IgKmVycm9yID0gTlVMTDsKCWlmIChwcmludF9zZXR0aW5ncykKCQlndGtfcHJp bnRfb3BlcmF0aW9uX3NldF9wcmludF9zZXR0aW5ncyhvcGVyYXRpb24sICpwcmludF9zZXR0aW5n cyk7CgoJd2Via2l0X3dlYl9mcmFtZV9wcmludChmcmFtZSwgb3BlcmF0aW9uLCBHVEtfUFJJTlRf T1BFUkFUSU9OX0FDVElPTl9QUklOVF9ESUFMT0csICZlcnJvcik7CglpZiAoIWVycm9yICYmIGd0 a19wcmludF9vcGVyYXRpb25fZ2V0X3ByaW50X3NldHRpbmdzKG9wZXJhdGlvbikgIT0gTlVMTCkg ewoJCWlmIChwcmludF9zZXR0aW5ncykKCQkJKnByaW50X3NldHRpbmdzID0gZ19vYmplY3RfcmVm KAoJCQkJCWd0a19wcmludF9vcGVyYXRpb25fZ2V0X3ByaW50X3NldHRpbmdzKG9wZXJhdGlvbikp OwoJfSBlbHNlIHsKCQlnX2Vycm9yX2ZyZWUoZXJyb3IpOwoJfQoJZ19vYmplY3RfdW5yZWYob3Bl cmF0aW9uKTsKfQoKLyogQ2FsbGVyIGFwcCBoYW5kbGVzIHByaW50IHJlcXVlc3RzIGZyb20gV2Vi S2l0IChqYXZhc2NyaXB0OnByaW50KCkgZm9yIGV4YW1wbGUpICovCnN0YXRpYyBnYm9vbGVhbiBw cmludF9zaWduYWxfaGFuZGxlcihXZWJLaXRXZWJGcmFtZSAqZnJhbWUsIGdwb2ludGVyIGRhdGEp CnsKCXByaW50X2RpYWxvZ19mcmFtZShmcmFtZSwgTlVMTCk7CglyZXR1cm4gVFJVRTsKfQoKLyog Q2FsbGVyIGFwcCBzZXRzIHVwIHByaW50IHJlcXVlc3RzIGZyb20gV2ViS2l0IGhhbmRsZXIgKGph dmFzY3JpcHQ6cHJpbnQoKSBmb3IgZXhhbXBsZSkgKi8Kdm9pZCBzZXR1cF9zaWduYWxfaGFuZGxl cihXZWJLaXRXZWJWaWV3ICp3ZWJ2aWV3KQp7CglnX3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKHdl YnZpZXcpLCAicHJpbnQtcmVxdWVzdGVkIiwgCgkJCSBHX0NBTExCQUNLKHByaW50X3NpZ25hbF9o YW5kbGVyKSwgTlVMTCk7Cn0K 29055 2009-03-30 01:39:28 -0700 2009-03-30 01:39:28 -0700 (Fixed) API usage example example.c text/x-csrc 1698 colin LyogQ2FsbGVyIGFwcCBleHBvcnRzIHRvIGZpbGUgYnkgaXRzZWxmICovCnZvaWQgZXhwb3J0X3Bh Z2UoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBHdGtQcmludFNldHRpbmdzICpwcmludF9zZXR0aW5n cykKewoJR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRpb25f bmV3KCk7CglHRXJyb3IgKmVycm9yID0gTlVMTDsKCWd0a19wcmludF9vcGVyYXRpb25fc2V0X2V4 cG9ydF9maWxlbmFtZShvcGVyYXRpb24sIGZpbGVuYW1lKTsKCWd0a19wcmludF9vcGVyYXRpb25f c2V0X3ByaW50X3NldHRpbmdzKG9wZXJhdGlvbiwgcHJpbnRfc2V0dGluZ3MpOwoKCXdlYmtpdF93 ZWJfZnJhbWVfcHJpbnQoZnJhbWUsIG9wZXJhdGlvbiwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJ T05fRVhQT1JULCAmZXJyb3IpOwoJaWYgKGVycm9yKQoJCWdfZXJyb3JfZnJlZShlcnJvcik7CgoJ Z19vYmplY3RfdW5yZWYob3BlcmF0aW9uKTsKfQoKLyogQ2FsbGVyIGFwcCBwcmludHMgYnkgaXRz ZWxmIChGaWxlL1ByaW50IGZvciBleGFtcGxlKSAqLwp2b2lkIHByaW50X2RpYWxvZ19mcmFtZShX ZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50U2V0dGluZ3MgKipwcmludF9zZXR0aW5ncykK ewoJR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRpb25fbmV3 KCk7CglHRXJyb3IgKmVycm9yID0gTlVMTDsKCWlmIChwcmludF9zZXR0aW5ncykKCQlndGtfcHJp bnRfb3BlcmF0aW9uX3NldF9wcmludF9zZXR0aW5ncyhvcGVyYXRpb24sICpwcmludF9zZXR0aW5n cyk7CgoJd2Via2l0X3dlYl9mcmFtZV9wcmludChmcmFtZSwgb3BlcmF0aW9uLCBHVEtfUFJJTlRf T1BFUkFUSU9OX0FDVElPTl9QUklOVF9ESUFMT0csICZlcnJvcik7CglpZiAoIWVycm9yICYmIGd0 a19wcmludF9vcGVyYXRpb25fZ2V0X3ByaW50X3NldHRpbmdzKG9wZXJhdGlvbikgIT0gTlVMTCkg ewoJCWlmIChwcmludF9zZXR0aW5ncykKCQkJKnByaW50X3NldHRpbmdzID0gZ19vYmplY3RfcmVm KAoJCQkJCWd0a19wcmludF9vcGVyYXRpb25fZ2V0X3ByaW50X3NldHRpbmdzKG9wZXJhdGlvbikp OwoJfSBlbHNlIHsKCQlnX2Vycm9yX2ZyZWUoZXJyb3IpOwoJfQoJZ19vYmplY3RfdW5yZWYob3Bl cmF0aW9uKTsKfQoKLyogQ2FsbGVyIGFwcCBoYW5kbGVzIHByaW50IHJlcXVlc3RzIGZyb20gV2Vi S2l0IChqYXZhc2NyaXB0OnByaW50KCkgZm9yIGV4YW1wbGUpICovCnN0YXRpYyBnYm9vbGVhbiBw cmludF9zaWduYWxfaGFuZGxlcihXZWJLaXRXZWJWaWV3ICp3ZWJ2aWV3LCBncG9pbnRlciBkYXRh KQp7CglXZWJLaXRXZWJGcmFtZSAqZnJhbWUgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X21haW5fZnJh bWUoV0VCS0lUX1dFQl9WSUVXKHdlYnZpZXcpKTsKCXByaW50X2RpYWxvZ19mcmFtZShmcmFtZSwg TlVMTCk7CglyZXR1cm4gVFJVRTsKfQoKLyogQ2FsbGVyIGFwcCBzZXRzIHVwIHByaW50IHJlcXVl c3RzIGZyb20gV2ViS2l0IGhhbmRsZXIgKGphdmFzY3JpcHQ6cHJpbnQoKSBmb3IgZXhhbXBsZSkg Ki8Kdm9pZCBzZXR1cF9zaWduYWxfaGFuZGxlcihXZWJLaXRXZWJWaWV3ICp3ZWJ2aWV3KQp7Cgln X3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKHdlYnZpZXcpLCAicHJpbnQtcmVxdWVzdGVkIiwgCgkJ CSBHX0NBTExCQUNLKHByaW50X3NpZ25hbF9oYW5kbGVyKSwgTlVMTCk7Cn0K 29121 2009-03-31 09:33:38 -0700 2009-04-03 07:07:32 -0700 proposed printing API API.patch text/plain 10765 gustavo YzEzNWMzZjUxOTk0ZGZjNTc0MjNlNTlmZGI0YWFmNTM0NzIwYTliYgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCA3MzlmMDBmLi5i MzgyNTNkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDA5LTAzLTMxICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y Mjg5OAorICAgICAgICBbR1RLXSBuZWVkIHByb3BlciBBUEkgZm9yIHByaW50aW5nCisKKyAgICAg ICAgSW1wbGVtZW50IHByb3BlciBwcmludGluZyBBUEksIHVzaW5nIHRoZSBHVEsrIHByaW50aW5n IEFQSS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OkNocm9tZUNsaWVudDo6cHJpbnQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0 d2Vidmlldy5jcHA6CisKIDIwMDktMDMtMzEgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rh dm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2Vy IEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVD bGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsu Y3BwCmluZGV4IDg1ZjcwNGEuLjIzMTAxMmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBw b3J0L0Nocm9tZUNsaWVudEd0ay5jcHAKQEAgLTQwNCw3ICs0MDQsMTQgQEAgdm9pZCBDaHJvbWVD bGllbnQ6OnNldFRvb2xUaXAoY29uc3QgU3RyaW5nJiB0b29sVGlwKQogCiB2b2lkIENocm9tZUNs aWVudDo6cHJpbnQoRnJhbWUqIGZyYW1lKQogewotICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQo a2l0KGZyYW1lKSk7CisgICAgV2ViS2l0V2ViRnJhbWUqIHdlYkZyYW1lID0ga2l0KGZyYW1lKTsK KyAgICBnYm9vbGVhbiBpc0hhbmRsZWQgPSBmYWxzZTsKKyAgICBnX3NpZ25hbF9lbWl0X2J5X25h bWUobV93ZWJWaWV3LCAicHJpbnQtcmVxdWVzdGVkIiwgd2ViRnJhbWUsICZpc0hhbmRsZWQpOwor CisgICAgaWYgKGlzSGFuZGxlZCkKKyAgICAgICAgcmV0dXJuOworCisgICAgd2Via2l0X3dlYl9m cmFtZV9wcmludCh3ZWJGcmFtZSk7CiB9CiAKIHZvaWQgQ2hyb21lQ2xpZW50OjpleGNlZWRlZERh dGFiYXNlUXVvdGEoRnJhbWUqIGZyYW1lLCBjb25zdCBTdHJpbmcmKQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5oCmluZGV4IDBiODNhMTEuLjgyMzBiODYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKQEAgLTE3Niw5ICsxNzYsNiBAQCBleHRlcm4gIkMiIHsKICAgICBXRUJLSVRfQVBJIGdj aGFyKgogICAgIHdlYmtpdF93ZWJfZnJhbWVfZ2V0X2lubmVyX3RleHQgKFdlYktpdFdlYkZyYW1l KiBmcmFtZSk7CiAKLSAgICBXRUJLSVRfQVBJIHZvaWQKLSAgICB3ZWJraXRfd2ViX2ZyYW1lX3By aW50IChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwotCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAg ICB3ZWJraXRfd2ViX2ZyYW1lX2R1bXBfcmVuZGVyX3RyZWUgKFdlYktpdFdlYkZyYW1lKiBmcmFt ZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAppbmRleCBlMmIxMGI2Li5mNTEw MWU0IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysr IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCkBAIC02LDYgKzYsNyBAQAog ICogQ29weXJpZ2h0IChDKSAyMDA4IENvbGxhYm9yYSBMdGQuCiAgKiBDb3B5cmlnaHQgKEMpIDIw MDggTnVhbnRpIEx0ZC4KICAqIENvcHlyaWdodCAoQykgMjAwOSBKYW4gQWxvbnpvIDxqbWFsb256 b0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZh IDxnbnNAZ25vbWUub3JnPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC02MTAsOSArNjExLDcgQEAg Z2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfZHVtcF9yZW5kZXJfdHJlZShXZWJLaXRXZWJGcmFtZSog ZnJhbWUpCiAgICAgcmV0dXJuIGdfc3RyZHVwKHN0cmluZy51dGY4KCkuZGF0YSgpKTsKIH0KIAot I2lmIEdUS19DSEVDS19WRVJTSU9OKDIsMTAsMCkKLQotc3RhdGljIHZvaWQgYmVnaW5fcHJpbnQo R3RrUHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdwb2ludGVy IHVzZXJfZGF0YSkKK3N0YXRpYyB2b2lkIGJlZ2luX3ByaW50X2NhbGxiYWNrKEd0a1ByaW50T3Bl cmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEp CiB7CiAgICAgUHJpbnRDb250ZXh0KiBwcmludENvbnRleHQgPSByZWludGVycHJldF9jYXN0PFBy aW50Q29udGV4dCo+KHVzZXJfZGF0YSk7CiAKQEAgLTYzMCw3ICs2MjksNyBAQCBzdGF0aWMgdm9p ZCBiZWdpbl9wcmludChHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29udGV4dCogY29u dGV4dCwgZ3BvaW50ZQogICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X25fcGFnZXMob3AsIHBy aW50Q29udGV4dC0+cGFnZUNvdW50KCkpOwogfQogCi1zdGF0aWMgdm9pZCBkcmF3X3BhZ2UoR3Rr UHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdpbnQgcGFnZV9u ciwgZ3BvaW50ZXIgdXNlcl9kYXRhKQorc3RhdGljIHZvaWQgZHJhd19wYWdlX2NhbGxiYWNrKEd0 a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2Vf bnIsIGdwb2ludGVyIHVzZXJfZGF0YSkKIHsKICAgICBQcmludENvbnRleHQqIHByaW50Q29udGV4 dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UHJpbnRDb250ZXh0Kj4odXNlcl9kYXRhKTsKIApAQCAtNjQw LDUzICs2MzksODIgQEAgc3RhdGljIHZvaWQgZHJhd19wYWdlKEd0a1ByaW50T3BlcmF0aW9uKiBv cCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2UKICAgICBwcmludENvbnRleHQt PnNwb29sUGFnZShjdHgsIHBhZ2VfbnIsIHdpZHRoKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX3By aW50KEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9p bnRlciB1c2VyX2RhdGEpCitzdGF0aWMgdm9pZCBlbmRfcHJpbnRfY2FsbGJhY2soR3RrUHJpbnRP cGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdwb2ludGVyIHVzZXJfZGF0 YSkKIHsKICAgICBQcmludENvbnRleHQqIHByaW50Q29udGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8 UHJpbnRDb250ZXh0Kj4odXNlcl9kYXRhKTsKICAgICBwcmludENvbnRleHQtPmVuZCgpOwogfQog CisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6CisgKiBAZnJhbWU6IGEgI1dlYktpdFdl YkZyYW1lCisgKgorICogUHJpbnRzIHRoZSBnaXZlbiAjV2ViS2l0RnJhbWUsIHVzaW5nIHRoZSBk ZWZhdWx0IHByaW50IHNldHRpbmdzLAorICogYW5kIHdpdGggbm8gdHJhY2tpbmcgb2YgdGhlIG9w ZXJhdGlvbi4gSWYgeW91IG5lZWQgbW9yZSBjb250cm9sCisgKiBvdmVyIHRoZSBwcmludGluZyBw cm9jZXNzLCBzZWUgd2Via2l0X3dlYl9mcmFtZV9wcmludF9mdWxsKCkuCisgKgorICogU2luY2U6 IDEuMS40CisgKi8KIHZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSog ZnJhbWUpCiB7Ci0gICAgR3RrV2lkZ2V0KiB0b3BMZXZlbCA9IGd0a193aWRnZXRfZ2V0X3RvcGxl dmVsKEdUS19XSURHRVQod2Via2l0X3dlYl9mcmFtZV9nZXRfd2ViX3ZpZXcoZnJhbWUpKSk7Ci0g ICAgaWYgKCFHVEtfV0lER0VUX1RPUExFVkVMKHRvcExldmVsKSkKLSAgICAgICAgdG9wTGV2ZWwg PSBOVUxMOwotCi0gICAgRnJhbWUqIGNvcmVGcmFtZSA9IGNvcmUoZnJhbWUpOwotICAgIGlmICgh Y29yZUZyYW1lKQotICAgICAgICByZXR1cm47CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRf SVNfV0VCX0ZSQU1FKGZyYW1lKSk7CiAKLSAgICBQcmludENvbnRleHQgcHJpbnRDb250ZXh0KGNv cmVGcmFtZSk7CisgICAgV2ViS2l0V2ViRnJhbWVQcml2YXRlKiBwcml2ID0gZnJhbWUtPnByaXY7 CisgICAgR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRpb25f bmV3KCk7CisgICAgR0Vycm9yKiBlcnJvciA9IDA7CiAKLSAgICBHdGtQcmludE9wZXJhdGlvbiog b3AgPSBndGtfcHJpbnRfb3BlcmF0aW9uX25ldygpOwotICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3As ICJiZWdpbi1wcmludCIsIEdfQ0FMTEJBQ0soYmVnaW5fcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsK LSAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiZHJhdy1wYWdlIiwgR19DQUxMQkFDSyhkcmF3X3Bh Z2UpLCAmcHJpbnRDb250ZXh0KTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiZW5kLXByaW50 IiwgR19DQUxMQkFDSyhlbmRfcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsKLSAgICBHRXJyb3IgKmVy cm9yID0gTlVMTDsKLSAgICBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bihvcCwgR1RLX1BSSU5UX09Q RVJBVElPTl9BQ1RJT05fUFJJTlRfRElBTE9HLCBHVEtfV0lORE9XKHRvcExldmVsKSwgJmVycm9y KTsKLSAgICBnX29iamVjdF91bnJlZihvcCk7CisgICAgd2Via2l0X3dlYl9mcmFtZV9wcmludF9m dWxsKGZyYW1lLCBvcGVyYXRpb24sIEdUS19QUklOVF9PUEVSQVRJT05fQUNUSU9OX1BSSU5UX0RJ QUxPRywgJmVycm9yKTsKKyAgICBnX29iamVjdF91bnJlZihvcGVyYXRpb24pOwogCiAgICAgaWYg KGVycm9yKSB7Ci0gICAgICAgIEd0a1dpZGdldCogZGlhbG9nID0gZ3RrX21lc3NhZ2VfZGlhbG9n X25ldyhHVEtfV0lORE9XKHRvcExldmVsKSwKKyAgICAgICAgR3RrV2lkZ2V0KiB3aW5kb3cgPSBn dGtfd2lkZ2V0X2dldF90b3BsZXZlbChHVEtfV0lER0VUKHByaXYtPndlYlZpZXcpKTsKKyAgICAg ICAgR3RrV2lkZ2V0KiBkaWFsb2cgPSBndGtfbWVzc2FnZV9kaWFsb2dfbmV3KEdUS19XSURHRVRf VE9QTEVWRUwod2luZG93KSA/IEdUS19XSU5ET1cod2luZG93KSA6IDAsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfRElBTE9HX0RFU1RST1lf V0lUSF9QQVJFTlQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBHVEtfTUVTU0FHRV9FUlJPUiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NFLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiVzIiwgZXJyb3ItPm1lc3NhZ2Up OwogICAgICAgICBnX2Vycm9yX2ZyZWUoZXJyb3IpOwogCi0gICAgICAgIGdfc2lnbmFsX2Nvbm5l Y3QoZGlhbG9nLCAicmVzcG9uc2UiLCBHX0NBTExCQUNLKGd0a193aWRnZXRfZGVzdHJveSksIE5V TEwpOworICAgICAgICBnX3NpZ25hbF9jb25uZWN0KGRpYWxvZywgInJlc3BvbnNlIiwgR19DQUxM QkFDSyhndGtfd2lkZ2V0X2Rlc3Ryb3kpLCAwKTsKICAgICAgICAgZ3RrX3dpZGdldF9zaG93KGRp YWxvZyk7CiAgICAgfQogfQogCi0jZWxzZQotCi12b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQo V2ViS2l0V2ViRnJhbWUqKQorLyoqCisgKiB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGw6Cisg KiBAZnJhbWU6IGEgI1dlYktpdFdlYkZyYW1lCisgKiBAb3BlcmF0aW9uOiB0aGUgI0d0a1ByaW50 T3BlcmF0aW9uIHRvIGJlIGNhcnJpZWQKKyAqIEBhY3Rpb246IHRoZSAjR3RrUHJpbnRPcGVyYXRp b25BY3Rpb24gdG8gYmUgcGVyZm9ybWVkCisgKiBAZXJyb3I6ICNHRXJyb3IgZm9yIGVycm9yIHJl dHVybgorICoKKyAqIFByaW50cyB0aGUgZ2l2ZW4gI1dlYktpdEZyYW1lLCB1c2luZyB0aGUgZ2l2 ZW4gI0d0a1ByaW50T3BlcmF0aW9uCisgKiBhbmQgI0d0a1ByaW50T3BlcmF0aW9uQWN0aW9uLiBU aGlzIGZ1bmN0aW9uIHdyYXBzIGEgY2FsbCB0bworICogZ3RrX3ByaW50X29wZXJhdGlvbl9ydW4o KSBmb3IgcHJpbnRpbmcgdGhlIGNvbnRlbnRzIG9mIHRoZQorICogI1dlYktpdFdlYkZyYW1lLgor ICoKKyAqIFNpbmNlOiAxLjEuNAorICovCitHdGtQcmludE9wZXJhdGlvblJlc3VsdCB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50X2Z1bGwoV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBHdGtQcmludE9wZXJh dGlvbiogb3BlcmF0aW9uLCBHdGtQcmludE9wZXJhdGlvbkFjdGlvbiBhY3Rpb24sIEdFcnJvcioq IGVycm9yKQogewotICAgIGdfd2FybmluZygiUHJpbnRpbmcgc3VwcG9ydCBpcyBub3QgYXZhaWxh YmxlIGluIG9sZGVyIHZlcnNpb25zIG9mIEdUSysiKTsKLX0KKyAgICBnX3JldHVybl92YWxfaWZf ZmFpbChXRUJLSVRfSVNfV0VCX0ZSQU1FKGZyYW1lKSwgR1RLX1BSSU5UX09QRVJBVElPTl9SRVNV TFRfRVJST1IpOworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKEdUS19JU19QUklOVF9PUEVSQVRJ T04ob3BlcmF0aW9uKSwgR1RLX1BSSU5UX09QRVJBVElPTl9SRVNVTFRfRVJST1IpOwogCi0jZW5k aWYKKyAgICBHdGtXaWRnZXQqIHRvcExldmVsID0gZ3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RL X1dJREdFVCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhmcmFtZSkpKTsKKyAgICBpZiAo IUdUS19XSURHRVRfVE9QTEVWRUwodG9wTGV2ZWwpKQorICAgICAgICB0b3BMZXZlbCA9IE5VTEw7 CisKKyAgICBGcmFtZSogY29yZUZyYW1lID0gY29yZShmcmFtZSk7CisgICAgaWYgKCFjb3JlRnJh bWUpCisgICAgICAgIHJldHVybiBHVEtfUFJJTlRfT1BFUkFUSU9OX1JFU1VMVF9DQU5DRUw7CisK KyAgICBQcmludENvbnRleHQgcHJpbnRDb250ZXh0KGNvcmVGcmFtZSk7CisKKyAgICBnX3NpZ25h bF9jb25uZWN0KG9wZXJhdGlvbiwgImJlZ2luLXByaW50IiwgR19DQUxMQkFDSyhiZWdpbl9wcmlu dF9jYWxsYmFjayksICZwcmludENvbnRleHQpOworICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3BlcmF0 aW9uLCAiZHJhdy1wYWdlIiwgR19DQUxMQkFDSyhkcmF3X3BhZ2VfY2FsbGJhY2spLCAmcHJpbnRD b250ZXh0KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KG9wZXJhdGlvbiwgImVuZC1wcmludCIsIEdf Q0FMTEJBQ0soZW5kX3ByaW50X2NhbGxiYWNrKSwgJnByaW50Q29udGV4dCk7CisKKyAgICByZXR1 cm4gZ3RrX3ByaW50X29wZXJhdGlvbl9ydW4ob3BlcmF0aW9uLCBhY3Rpb24sIEdUS19XSU5ET1co dG9wTGV2ZWwpLCBlcnJvcik7Cit9CiAKIGJvb2wgd2Via2l0X3dlYl9mcmFtZV9wYXVzZV9hbmlt YXRpb24oV2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBjb25zdCBnY2hhciogbmFtZSwgZG91YmxlIHRp bWUsIGNvbnN0IGdjaGFyKiBlbGVtZW50KQogewpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2ViZnJhbWUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgK aW5kZXggN2UyNDU2NS4uMWUzNWUxZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2ViZnJhbWUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oCkBA IC0yMiw2ICsyMiw4IEBACiAjZGVmaW5lIFdFQktJVF9XRUJfRlJBTUVfSAogCiAjaW5jbHVkZSA8 Z2xpYi1vYmplY3QuaD4KKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisKICNpbmNsdWRlIDxKYXZhU2Ny aXB0Q29yZS9KU0Jhc2UuaD4KIAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CkBA IC0xMDgsNiArMTEwLDE1IEBAIHdlYmtpdF93ZWJfZnJhbWVfZmluZF9mcmFtZSAgICAgICAgIChX ZWJLaXRXZWJGcmFtZSAgICAgICAqZnJhbWUsCiBXRUJLSVRfQVBJIEpTR2xvYmFsQ29udGV4dFJl Zgogd2Via2l0X3dlYl9mcmFtZV9nZXRfZ2xvYmFsX2NvbnRleHQgKFdlYktpdFdlYkZyYW1lICAg ICAgICpmcmFtZSk7CiAKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl9mcmFtZV9wcmludCAg ICAgICAgICAgICAgKFdlYktpdFdlYkZyYW1lICAgICAgICpmcmFtZSk7CisKK1dFQktJVF9BUEkg R3RrUHJpbnRPcGVyYXRpb25SZXN1bHQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnRfZnVsbCAgICAg ICAgIChXZWJLaXRXZWJGcmFtZSAgICAgICAqZnJhbWUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR3RrUHJpbnRPcGVyYXRpb24gICAgKm9wZXJhdGlvbiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHdGtQcmludE9wZXJhdGlvbkFjdGlvbiBhY3Rp b24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0Vycm9yICAgICAgICAg ICAgICAqKmVycm9yKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuY3BwCmluZGV4IDdmMzc5NWUuLjYxZDdiNTQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuY3BwCkBAIC0xMzgsNiArMTM4LDcgQEAgZW51bSB7CiAgICAgQ1VUX0NMSVBCT0FS RCwKICAgICBET1dOTE9BRF9SRVFVRVNURUQsCiAgICAgTU9WRV9DVVJTT1IsCisgICAgUFJJTlRf UkVRVUVTVEVELAogICAgIExBU1RfU0lHTkFMCiB9OwogCkBAIC0xMzI4LDYgKzEzMjksMzQgQEAg c3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2NsYXNzX2luaXQoV2ViS2l0V2ViVmlld0NsYXNz KiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAgICBHX1RZUEVfTk9ORSwgMSwKICAgICAgICAgICAg IEdUS19UWVBFX01FTlUpOwogCisgICAgLyoqCisgICAgICogV2ViS2l0V2ViVmlldzo6cHJpbnQt cmVxdWVzdGVkCisgICAgICogQHdlYl92aWV3OiB0aGUgb2JqZWN0IGluIHdoaWNoIHRoZSBzaWdu YWwgaXMgZW1pdHRlZAorICAgICAqIEB3ZWJfZnJhbWU6IHRoZSBmcmFtZSB0aGF0IGlzIHJlcXVl c3RpbmcgdG8gYmUgcHJpbnRlZAorICAgICAqIEByZXR1cm46ICVUUlVFIGlmIHRoZSBwcmludCBy ZXF1ZXN0IGhhcyBiZWVuIGhhbmRsZWQsICVGQUxTRSBpZgorICAgICAqIHRoZSBkZWZhdWx0IGhh bmRsZXIgc2hvdWxkIHJ1bgorICAgICAqCisgICAgICogRW1pdHRlZCB3aGVuIHByaW50aW5nIGlz IHJlcXVlc3RlZCBieSB0aGUgZnJhbWUsIHVzdWFsbHkKKyAgICAgKiBiZWNhdXNlIG9mIGEgamF2 YXNjcmlwdCBjYWxsLiBXaGlsZSBoYW5kbGluZyB0aGlzIHNpZ25hbCB5b3UKKyAgICAgKiBzaG91 bGQgY2FsbCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50KCkgdG8gZG8gdGhlIGFjdHVhbCBwcmludGlu Zy4KKyAgICAgKgorICAgICAqIFRoZSBkZWZhdWx0IGhhbmRsZXIgd2lsbCBwcmVzZW50IGEgcHJp bnQgZGlhbG9nIGFuZCBjYXJyeSBhCisgICAgICogcHJpbnQgb3BlcmF0aW9uLiBOb3RpY2UgdGhh dCB0aGlzIG1lYW5zIHRoYXQgaWYgeW91IGludGVuZCB0bworICAgICAqIGlnbm9yZSBhIHByaW50 IHJlcXVlc3QgeW91IG11c3QgY29ubmVjdCB0byB0aGlzIHNpZ25hbCwgYW5kCisgICAgICogcmV0 dXJuICVUUlVFLgorICAgICAqCisgICAgICogU2luY2U6IDEuMS40CisgICAgICovCisgICAgd2Vi a2l0X3dlYl92aWV3X3NpZ25hbHNbUFJJTlRfUkVRVUVTVEVEXSA9IGdfc2lnbmFsX25ldygicHJp bnQtcmVxdWVzdGVkIiwKKyAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFz cyksCisgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFTVCB8IEdfU0lH TkFMX0FDVElPTiksCisgICAgICAgICAgICAwLAorICAgICAgICAgICAgTlVMTCwKKyAgICAgICAg ICAgIE5VTEwsCisgICAgICAgICAgICB3ZWJraXRfbWFyc2hhbF9CT09MRUFOX19PQkpFQ1QsCisg ICAgICAgICAgICBHX1RZUEVfQk9PTEVBTiwgMSwKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX1dF Ql9GUkFNRSk7CisKICAgICB3ZWJraXRfd2ViX3ZpZXdfc2lnbmFsc1tTVEFUVVNfQkFSX1RFWFRf Q0hBTkdFRF0gPSBnX3NpZ25hbF9uZXcoInN0YXR1cy1iYXItdGV4dC1jaGFuZ2VkIiwKICAgICAg ICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCiAgICAgICAgICAgICAoR1Np Z25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCg== 29122 2009-03-31 09:33:43 -0700 2009-04-03 07:07:49 -0700 unit tests for printing unittests.patch text/plain 4806 gustavo NzU5ZjUzNDdmMjQ0NzNlZDVhYjRkYTUzMTFlNDhhMzQzNjVmMjVhNgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBiMzgyNTNkLi4z NmFlNGJjIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtNSw2ICs1LDIxIEBACiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMjg5OAogICAgICAgICBbR1RLXSBuZWVkIHByb3BlciBBUEkg Zm9yIHByaW50aW5nCiAKKyAgICAgICAgQWRkZWQgc2ltcGxlIHByaW50aW5nIHVuaXQgdGVzdHMu CisKKyAgICAgICAgKiB0ZXN0cy90ZXN0d2ViZnJhbWUuYzoKKyAgICAgICAgKHByaW50X3JlcXVl c3RlZF9jYik6CisgICAgICAgIChwcmludF90aW1lb3V0KToKKyAgICAgICAgKHRlc3Rfd2Via2l0 X3dlYl9mcmFtZV9wcmludGluZyk6CisgICAgICAgIChtYWluKToKKworMjAwOS0wMy0zMSAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4OTgKKyAgICAgICAgW0dUS10gbmVlZCBw cm9wZXIgQVBJIGZvciBwcmludGluZworCiAgICAgICAgIEltcGxlbWVudCBwcm9wZXIgcHJpbnRp bmcgQVBJLCB1c2luZyB0aGUgR1RLKyBwcmludGluZyBBUEkuCiAKICAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwOgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay90ZXN0 cy90ZXN0d2ViZnJhbWUuYyBiL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdlYmZyYW1lLmMKaW5kZXgg ZTJkYTI5Yy4uMTk2ZDNiYyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2ViZnJh bWUuYworKysgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3R3ZWJmcmFtZS5jCkBAIC0xLDUgKzEsNiBA QAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgor ICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCiAgKgogICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMK QEAgLTE3LDcgKzE4LDkgQEAKICAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgogICovCiAK KyNpbmNsdWRlIDx1bmlzdGQuaD4KICNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8Z2xpYi9n c3RkaW8uaD4KICNpbmNsdWRlIDxndGsvZ3RrLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdC5o PgogCkBAIC02Miw2ICs2NSw4MyBAQCBzdGF0aWMgdm9pZCB0ZXN0X3dlYmtpdF93ZWJfZnJhbWVf bGlmZXRpbWUodm9pZCkKICAgICBnX29iamVjdF91bnJlZih3ZWJGcmFtZSk7CiB9CiAKK3N0YXRp YyBnYm9vbGVhbiBwcmludF9yZXF1ZXN0ZWRfY2IoV2ViS2l0V2ViVmlldyogd2ViVmlldywgV2Vi S2l0V2ViRnJhbWUqIHdlYkZyYW1lLCBHTWFpbkxvb3AqIGxvb3ApCit7CisgICAgZ19vYmplY3Rf c2V0X2RhdGEoR19PQkpFQ1Qod2ViVmlldyksICJzaWduYWwtaGFuZGxlZCIsIEdJTlRfVE9fUE9J TlRFUihUUlVFKSk7CisgICAgZ19tYWluX2xvb3BfcXVpdChsb29wKTsKKyAgICByZXR1cm4gVFJV RTsKK30KKworc3RhdGljIHByaW50X3RpbWVvdXQoR01haW5Mb29wKiBsb29wKQoreworICAgIGlm IChnX21haW5fbG9vcF9pc19ydW5uaW5nKGxvb3ApKQorICAgICAgICBnX21haW5fbG9vcF9xdWl0 KGxvb3ApOworfQorCitzdGF0aWMgdm9pZCB0ZXN0X3dlYmtpdF93ZWJfZnJhbWVfcHJpbnRpbmco dm9pZCkKK3sKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3OworCisgICAgd2ViVmlldyA9IFdF QktJVF9XRUJfVklFVyh3ZWJraXRfd2ViX3ZpZXdfbmV3KCkpOworICAgIGdfb2JqZWN0X3JlZl9z aW5rKHdlYlZpZXcpOworICAgIGdfYXNzZXJ0X2NtcGludChHX09CSkVDVCh3ZWJWaWV3KS0+cmVm X2NvdW50LCA9PSwgMSk7CisKKyAgICB3ZWJraXRfd2ViX3ZpZXdfbG9hZF9zdHJpbmcod2ViVmll dywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIjxodG1sPjxib2R5PjxoMT5XZWJL aXRHVEsrITwvaDE+PC9ib2R5PjwvaHRtbD4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAidGV4dC9odG1sIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInV0Zi04 IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImZpbGU6Ly8iKTsKKworICAgIEdN YWluTG9vcCogbG9vcCA9IGdfbWFpbl9sb29wX25ldyhOVUxMLCBUUlVFKTsKKworICAgIC8vIERv ZXMgamF2YXNjcmlwdCBwcmludCgpIHdvcmsgY29ycmVjdGx5PworICAgIGdfc2lnbmFsX2Nvbm5l Y3Qod2ViVmlldywgInByaW50LXJlcXVlc3RlZCIsCisgICAgICAgICAgICAgICAgICAgICBHX0NB TExCQUNLKHByaW50X3JlcXVlc3RlZF9jYiksCisgICAgICAgICAgICAgICAgICAgICBsb29wKTsK KworICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKHdlYlZpZXcpLCAic2lnbmFsLWhhbmRs ZWQiLCBHSU5UX1RPX1BPSU5URVIoRkFMU0UpKTsKKyAgICB3ZWJraXRfd2ViX3ZpZXdfZXhlY3V0 ZV9zY3JpcHQgKHdlYlZpZXcsICJwcmludCgpOyIpOworCisgICAgLy8gR2l2ZSBqYXZhc2NyaXB0 Y29yZSBzb21lIHRpbWUgdG8gcHJvY2VzcyB0aGUgcHJpbnQgcmVxdWVzdCwgYnV0CisgICAgLy8g cHJlcGFyZSBhIHRpbWVvdXQgdG8gYXZvaWQgaXQgcnVubmluZyBmb3JldmVyIGluIGNhc2UgdGhl IHNpZ25hbCBpcworICAgIC8vIG5ldmVyIGVtaXR0ZWQuCisgICAgZ190aW1lb3V0X2FkZCgxMDAw LCBwcmludF90aW1lb3V0LCBsb29wKTsKKyAgICBnX21haW5fbG9vcF9ydW4obG9vcCk7CisKKyAg ICBnX2Fzc2VydF9jbXBpbnQoR1BPSU5URVJfVE9fSU5UKGdfb2JqZWN0X2dldF9kYXRhKEdfT0JK RUNUKHdlYlZpZXcpLCAic2lnbmFsLWhhbmRsZWQiKSksID09LCBUUlVFKTsKKworICAgIC8vIERv ZXMgcHJpbnRpbmcgZGlyZWN0bHkgdG8gYSBmaWxlPworICAgIEdFcnJvciAqZXJyb3IgPSBOVUxM OworICAgIGdjaGFyKiB0ZW1wb3JhcnlGaWxlbmFtZSA9IE5VTEw7CisgICAgZ2ludCBmZCA9IGdf ZmlsZV9vcGVuX3RtcCAoIndlYmtpdC10ZXN0d2ViZnJhbWUtWFhYWFhYIiwgJnRlbXBvcmFyeUZp bGVuYW1lLCAmZXJyb3IpOworICAgIGNsb3NlKGZkKTsKKworICAgIC8vIFdlIGRlbGV0ZSB0aGUg ZmlsZSwgc28gdGhhdCB3ZSBjYW4gZWFzaWx5IGZpZ3VyZSBvdXQgdGhhdCB0aGUKKyAgICAvLyBm aWxlIGdvdCBwcmludGVkOworICAgIGlmIChlcnJvciB8fCAoZ191bmxpbmsodGVtcG9yYXJ5Rmls ZW5hbWUpID09IC0xKSkgeworICAgICAgICBnX2NyaXRpY2FsKCJGYWlsZWQgdG8gb3BlbiBhIHRl bXBvcmFyeSBmaWxlIGZvciB3cml0aW5nOiAlcy4iLCBlcnJvci0+bWVzc2FnZSk7CisgICAgICAg IGdfZXJyb3JfZnJlZShlcnJvcik7CisgICAgICAgIGdvdG8gY2xlYW51cDsKKyAgICB9CisKKyAg ICBXZWJLaXRXZWJGcmFtZSogd2ViRnJhbWUgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X21haW5fZnJh bWUod2ViVmlldyk7CisgICAgR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmlu dF9vcGVyYXRpb25fbmV3KCk7CisgICAgR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gYWN0aW9uID0g R1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fRVhQT1JUOworICAgIEd0a1ByaW50T3BlcmF0aW9u UmVzdWx0IHJlc3VsdDsKKworICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X2V4cG9ydF9maWxl bmFtZShvcGVyYXRpb24sIHRlbXBvcmFyeUZpbGVuYW1lKTsKKyAgICByZXN1bHQgPSB3ZWJraXRf d2ViX2ZyYW1lX3ByaW50X2Z1bGwgKHdlYkZyYW1lLCBvcGVyYXRpb24sIGFjdGlvbiwgZXJyb3Ip OworCisgICAgZ19hc3NlcnRfY21waW50KHJlc3VsdCwgPT0sIEdUS19QUklOVF9PUEVSQVRJT05f UkVTVUxUX0FQUExZKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoZ19maWxlX3Rlc3QodGVtcG9yYXJ5 RmlsZW5hbWUsIEdfRklMRV9URVNUX0lTX1JFR1VMQVIpLCA9PSwgVFJVRSk7CisKKyAgICBnX3Vu bGluayh0ZW1wb3JhcnlGaWxlbmFtZSk7CisgICAgZ19vYmplY3RfdW5yZWYob3BlcmF0aW9uKTsK K2NsZWFudXA6CisgICAgZ19vYmplY3RfdW5yZWYod2ViVmlldyk7CisgICAgZ19mcmVlKHRlbXBv cmFyeUZpbGVuYW1lKTsKK30KKwogaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2KQogewog ICAgIGdfdGhyZWFkX2luaXQoTlVMTCk7CkBAIC03MCw2ICsxNTAsNyBAQCBpbnQgbWFpbihpbnQg YXJnYywgY2hhcioqIGFyZ3YpCiAgICAgZ190ZXN0X2J1Z19iYXNlKCJodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy8iKTsKICAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvd2Vidmlldy9jcmVhdGVf ZGVzdHJveSIsIHRlc3Rfd2Via2l0X3dlYl9mcmFtZV9jcmVhdGVfZGVzdHJveSk7CiAgICAgZ190 ZXN0X2FkZF9mdW5jKCIvd2Via2l0L3dlYmZyYW1lL2xpZmV0aW1lIiwgdGVzdF93ZWJraXRfd2Vi X2ZyYW1lX2xpZmV0aW1lKTsKKyAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvd2Vidmlldy9w cmludGluZyIsIHRlc3Rfd2Via2l0X3dlYl9mcmFtZV9wcmludGluZyk7CiAgICAgcmV0dXJuIGdf dGVzdF9ydW4gKCk7CiB9CiAK 29226 2009-04-03 07:03:31 -0700 2009-04-06 14:40:35 -0700 proposed printing API 2009-03-31-Gustavo-Noronha-Silva-gns-gnome.org-.patch text/plain 10345 gustavo YjdkZjFiYWJmM2M4MTRlMDVlZTJiMjU1ODhmNTkyODcwM2RhODg4MgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCA5MTI1MTNjLi5l ZGNmZmI2IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDA5LTAzLTMxICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y Mjg5OAorICAgICAgICBbR1RLXSBuZWVkIHByb3BlciBBUEkgZm9yIHByaW50aW5nCisKKyAgICAg ICAgSW1wbGVtZW50IHByb3BlciBwcmludGluZyBBUEksIHVzaW5nIHRoZSBHVEsrIHByaW50aW5n IEFQSS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OkNocm9tZUNsaWVudDo6cHJpbnQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0 d2Vidmlldy5jcHA6CisKIDIwMDktMDQtMDMgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rh dm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2Vy IEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVD bGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsu Y3BwCmluZGV4IDg1ZjcwNGEuLjIzMTAxMmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBw b3J0L0Nocm9tZUNsaWVudEd0ay5jcHAKQEAgLTQwNCw3ICs0MDQsMTQgQEAgdm9pZCBDaHJvbWVD bGllbnQ6OnNldFRvb2xUaXAoY29uc3QgU3RyaW5nJiB0b29sVGlwKQogCiB2b2lkIENocm9tZUNs aWVudDo6cHJpbnQoRnJhbWUqIGZyYW1lKQogewotICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQo a2l0KGZyYW1lKSk7CisgICAgV2ViS2l0V2ViRnJhbWUqIHdlYkZyYW1lID0ga2l0KGZyYW1lKTsK KyAgICBnYm9vbGVhbiBpc0hhbmRsZWQgPSBmYWxzZTsKKyAgICBnX3NpZ25hbF9lbWl0X2J5X25h bWUobV93ZWJWaWV3LCAicHJpbnQtcmVxdWVzdGVkIiwgd2ViRnJhbWUsICZpc0hhbmRsZWQpOwor CisgICAgaWYgKGlzSGFuZGxlZCkKKyAgICAgICAgcmV0dXJuOworCisgICAgd2Via2l0X3dlYl9m cmFtZV9wcmludCh3ZWJGcmFtZSk7CiB9CiAKIHZvaWQgQ2hyb21lQ2xpZW50OjpleGNlZWRlZERh dGFiYXNlUXVvdGEoRnJhbWUqIGZyYW1lLCBjb25zdCBTdHJpbmcmKQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5oCmluZGV4IDBiODNhMTEuLjgyMzBiODYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2 YXRlLmgKQEAgLTE3Niw5ICsxNzYsNiBAQCBleHRlcm4gIkMiIHsKICAgICBXRUJLSVRfQVBJIGdj aGFyKgogICAgIHdlYmtpdF93ZWJfZnJhbWVfZ2V0X2lubmVyX3RleHQgKFdlYktpdFdlYkZyYW1l KiBmcmFtZSk7CiAKLSAgICBXRUJLSVRfQVBJIHZvaWQKLSAgICB3ZWJraXRfd2ViX2ZyYW1lX3By aW50IChXZWJLaXRXZWJGcmFtZSogZnJhbWUpOwotCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAg ICB3ZWJraXRfd2ViX2ZyYW1lX2R1bXBfcmVuZGVyX3RyZWUgKFdlYktpdFdlYkZyYW1lKiBmcmFt ZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcAppbmRleCAwMjllMDE2Li4zOWNi ZWY4IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysr IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCkBAIC02LDYgKzYsNyBAQAog ICogQ29weXJpZ2h0IChDKSAyMDA4IENvbGxhYm9yYSBMdGQuCiAgKiBDb3B5cmlnaHQgKEMpIDIw MDggTnVhbnRpIEx0ZC4KICAqIENvcHlyaWdodCAoQykgMjAwOSBKYW4gQWxvbnpvIDxqbWFsb256 b0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZh IDxnbnNAZ25vbWUub3JnPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC02MTAsNyArNjExLDcgQEAg Z2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfZHVtcF9yZW5kZXJfdHJlZShXZWJLaXRXZWJGcmFtZSog ZnJhbWUpCiAgICAgcmV0dXJuIGdfc3RyZHVwKHN0cmluZy51dGY4KCkuZGF0YSgpKTsKIH0KIAot c3RhdGljIHZvaWQgYmVnaW5fcHJpbnQoR3RrUHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENv bnRleHQqIGNvbnRleHQsIGdwb2ludGVyIHVzZXJfZGF0YSkKK3N0YXRpYyB2b2lkIGJlZ2luX3By aW50X2NhbGxiYWNrKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250 ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCiB7CiAgICAgUHJpbnRDb250ZXh0KiBwcmludENvbnRl eHQgPSByZWludGVycHJldF9jYXN0PFByaW50Q29udGV4dCo+KHVzZXJfZGF0YSk7CiAKQEAgLTYy OCw3ICs2MjksNyBAQCBzdGF0aWMgdm9pZCBiZWdpbl9wcmludChHdGtQcmludE9wZXJhdGlvbiog b3AsIEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ3BvaW50ZQogICAgIGd0a19wcmludF9vcGVy YXRpb25fc2V0X25fcGFnZXMob3AsIHByaW50Q29udGV4dC0+cGFnZUNvdW50KCkpOwogfQogCi1z dGF0aWMgdm9pZCBkcmF3X3BhZ2UoR3RrUHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRl eHQqIGNvbnRleHQsIGdpbnQgcGFnZV9uciwgZ3BvaW50ZXIgdXNlcl9kYXRhKQorc3RhdGljIHZv aWQgZHJhd19wYWdlX2NhbGxiYWNrKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250 ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2VfbnIsIGdwb2ludGVyIHVzZXJfZGF0YSkKIHsKICAgICBQ cmludENvbnRleHQqIHByaW50Q29udGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UHJpbnRDb250ZXh0 Kj4odXNlcl9kYXRhKTsKIApAQCAtNjM4LDM0ICs2MzksMzYgQEAgc3RhdGljIHZvaWQgZHJhd19w YWdlKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBnaW50 IHBhZ2UKICAgICBwcmludENvbnRleHQtPnNwb29sUGFnZShjdHgsIHBhZ2VfbnIsIHdpZHRoKTsK IH0KIAotc3RhdGljIHZvaWQgZW5kX3ByaW50KEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJp bnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCitzdGF0aWMgdm9pZCBlbmRf cHJpbnRfY2FsbGJhY2soR3RrUHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNv bnRleHQsIGdwb2ludGVyIHVzZXJfZGF0YSkKIHsKICAgICBQcmludENvbnRleHQqIHByaW50Q29u dGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UHJpbnRDb250ZXh0Kj4odXNlcl9kYXRhKTsKICAgICBw cmludENvbnRleHQtPmVuZCgpOwogfQogCisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6 CisgKiBAZnJhbWU6IGEgI1dlYktpdFdlYkZyYW1lCisgKgorICogUHJpbnRzIHRoZSBnaXZlbiAj V2ViS2l0RnJhbWUsIGJ5IHByZXNlbnRpbmcgYSBwcmludCBkaWFsb2cgdG8gdGhlCisgKiB1c2Vy LiBJZiB5b3UgbmVlZCBtb3JlIGNvbnRyb2wgb3ZlciB0aGUgcHJpbnRpbmcgcHJvY2Vzcywgc2Vl CisgKiB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGwoKS4KKyAqCisgKiBTaW5jZTogMS4xLjQK KyAqLwogdm9pZCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSkK IHsKLSAgICBHdGtXaWRnZXQqIHRvcExldmVsID0gZ3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RL X1dJREdFVCh3ZWJraXRfd2ViX2ZyYW1lX2dldF93ZWJfdmlldyhmcmFtZSkpKTsKLSAgICBpZiAo IUdUS19XSURHRVRfVE9QTEVWRUwodG9wTGV2ZWwpKQotICAgICAgICB0b3BMZXZlbCA9IE5VTEw7 Ci0KLSAgICBGcmFtZSogY29yZUZyYW1lID0gY29yZShmcmFtZSk7Ci0gICAgaWYgKCFjb3JlRnJh bWUpCi0gICAgICAgIHJldHVybjsKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9JU19XRUJf RlJBTUUoZnJhbWUpKTsKIAotICAgIFByaW50Q29udGV4dCBwcmludENvbnRleHQoY29yZUZyYW1l KTsKKyAgICBXZWJLaXRXZWJGcmFtZVByaXZhdGUqIHByaXYgPSBmcmFtZS0+cHJpdjsKKyAgICBH dGtQcmludE9wZXJhdGlvbiogb3BlcmF0aW9uID0gZ3RrX3ByaW50X29wZXJhdGlvbl9uZXcoKTsK KyAgICBHRXJyb3IqIGVycm9yID0gMDsKIAotICAgIEd0a1ByaW50T3BlcmF0aW9uKiBvcCA9IGd0 a19wcmludF9vcGVyYXRpb25fbmV3KCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChvcCwgImJlZ2lu LXByaW50IiwgR19DQUxMQkFDSyhiZWdpbl9wcmludCksICZwcmludENvbnRleHQpOwotICAgIGdf c2lnbmFsX2Nvbm5lY3Qob3AsICJkcmF3LXBhZ2UiLCBHX0NBTExCQUNLKGRyYXdfcGFnZSksICZw cmludENvbnRleHQpOwotICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJlbmQtcHJpbnQiLCBHX0NB TExCQUNLKGVuZF9wcmludCksICZwcmludENvbnRleHQpOwotICAgIEdFcnJvciAqZXJyb3IgPSBO VUxMOwotICAgIGd0a19wcmludF9vcGVyYXRpb25fcnVuKG9wLCBHVEtfUFJJTlRfT1BFUkFUSU9O X0FDVElPTl9QUklOVF9ESUFMT0csIEdUS19XSU5ET1codG9wTGV2ZWwpLCAmZXJyb3IpOwotICAg IGdfb2JqZWN0X3VucmVmKG9wKTsKKyAgICB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGwoZnJh bWUsIG9wZXJhdGlvbiwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fUFJJTlRfRElBTE9HLCAm ZXJyb3IpOworICAgIGdfb2JqZWN0X3VucmVmKG9wZXJhdGlvbik7CiAKICAgICBpZiAoZXJyb3Ip IHsKLSAgICAgICAgR3RrV2lkZ2V0KiBkaWFsb2cgPSBndGtfbWVzc2FnZV9kaWFsb2dfbmV3KEdU S19XSU5ET1codG9wTGV2ZWwpLAorICAgICAgICBHdGtXaWRnZXQqIHdpbmRvdyA9IGd0a193aWRn ZXRfZ2V0X3RvcGxldmVsKEdUS19XSURHRVQocHJpdi0+d2ViVmlldykpOworICAgICAgICBHdGtX aWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxvZ19uZXcoR1RLX1dJREdFVF9UT1BMRVZF TCh3aW5kb3cpID8gR1RLX1dJTkRPVyh3aW5kb3cpIDogMCwKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19ESUFMT0dfREVTVFJPWV9XSVRIX1BB UkVOVCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEdUS19NRVNTQUdFX0VSUk9SLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR1RLX0JVVFRPTlNfQ0xPU0UsCkBAIC02NzcsNiArNjgwLDQyIEBAIHZv aWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSogZnJhbWUpCiAgICAgfQog fQogCisvKioKKyAqIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnRfZnVsbDoKKyAqIEBmcmFtZTogYSAj V2ViS2l0V2ViRnJhbWUKKyAqIEBvcGVyYXRpb246IHRoZSAjR3RrUHJpbnRPcGVyYXRpb24gdG8g YmUgY2FycmllZAorICogQGFjdGlvbjogdGhlICNHdGtQcmludE9wZXJhdGlvbkFjdGlvbiB0byBi ZSBwZXJmb3JtZWQKKyAqIEBlcnJvcjogI0dFcnJvciBmb3IgZXJyb3IgcmV0dXJuCisgKgorICog UHJpbnRzIHRoZSBnaXZlbiAjV2ViS2l0RnJhbWUsIHVzaW5nIHRoZSBnaXZlbiAjR3RrUHJpbnRP cGVyYXRpb24KKyAqIGFuZCAjR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24uIFRoaXMgZnVuY3Rpb24g d3JhcHMgYSBjYWxsIHRvCisgKiBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bigpIGZvciBwcmludGlu ZyB0aGUgY29udGVudHMgb2YgdGhlCisgKiAjV2ViS2l0V2ViRnJhbWUuCisgKgorICogU2luY2U6 IDEuMS40CisgKi8KK0d0a1ByaW50T3BlcmF0aW9uUmVzdWx0IHdlYmtpdF93ZWJfZnJhbWVfcHJp bnRfZnVsbChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50T3BlcmF0aW9uKiBvcGVyYXRp b24sIEd0a1ByaW50T3BlcmF0aW9uQWN0aW9uIGFjdGlvbiwgR0Vycm9yKiogZXJyb3IpCit7Cisg ICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9GUkFNRShmcmFtZSksIEdUS19Q UklOVF9PUEVSQVRJT05fUkVTVUxUX0VSUk9SKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChH VEtfSVNfUFJJTlRfT1BFUkFUSU9OKG9wZXJhdGlvbiksIEdUS19QUklOVF9PUEVSQVRJT05fUkVT VUxUX0VSUk9SKTsKKworICAgIEd0a1dpZGdldCogdG9wTGV2ZWwgPSBndGtfd2lkZ2V0X2dldF90 b3BsZXZlbChHVEtfV0lER0VUKHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3dlYl92aWV3KGZyYW1lKSkp OworICAgIGlmICghR1RLX1dJREdFVF9UT1BMRVZFTCh0b3BMZXZlbCkpCisgICAgICAgIHRvcExl dmVsID0gTlVMTDsKKworICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKKyAgICBp ZiAoIWNvcmVGcmFtZSkKKyAgICAgICAgcmV0dXJuIEdUS19QUklOVF9PUEVSQVRJT05fUkVTVUxU X0VSUk9SOworCisgICAgUHJpbnRDb250ZXh0IHByaW50Q29udGV4dChjb3JlRnJhbWUpOworCisg ICAgZ19zaWduYWxfY29ubmVjdChvcGVyYXRpb24sICJiZWdpbi1wcmludCIsIEdfQ0FMTEJBQ0so YmVnaW5fcHJpbnRfY2FsbGJhY2spLCAmcHJpbnRDb250ZXh0KTsKKyAgICBnX3NpZ25hbF9jb25u ZWN0KG9wZXJhdGlvbiwgImRyYXctcGFnZSIsIEdfQ0FMTEJBQ0soZHJhd19wYWdlX2NhbGxiYWNr KSwgJnByaW50Q29udGV4dCk7CisgICAgZ19zaWduYWxfY29ubmVjdChvcGVyYXRpb24sICJlbmQt cHJpbnQiLCBHX0NBTExCQUNLKGVuZF9wcmludF9jYWxsYmFjayksICZwcmludENvbnRleHQpOwor CisgICAgcmV0dXJuIGd0a19wcmludF9vcGVyYXRpb25fcnVuKG9wZXJhdGlvbiwgYWN0aW9uLCBH VEtfV0lORE9XKHRvcExldmVsKSwgZXJyb3IpOworfQorCiBib29sIHdlYmtpdF93ZWJfZnJhbWVf cGF1c2VfYW5pbWF0aW9uKFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgY29uc3QgZ2NoYXIqIG5hbWUs IGRvdWJsZSB0aW1lLCBjb25zdCBnY2hhciogZWxlbWVudCkKIHsKICAgICBBU1NFUlQoY29yZShm cmFtZSkpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaCBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgKaW5kZXggN2UyNDU2NS4uMWUzNWUx ZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAorKysgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oCkBAIC0yMiw2ICsyMiw4IEBACiAjZGVm aW5lIFdFQktJVF9XRUJfRlJBTUVfSAogCiAjaW5jbHVkZSA8Z2xpYi1vYmplY3QuaD4KKyNpbmNs dWRlIDxndGsvZ3RrLmg+CisKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU0Jhc2UuaD4KIAog I2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CkBAIC0xMDgsNiArMTEwLDE1IEBAIHdl YmtpdF93ZWJfZnJhbWVfZmluZF9mcmFtZSAgICAgICAgIChXZWJLaXRXZWJGcmFtZSAgICAgICAq ZnJhbWUsCiBXRUJLSVRfQVBJIEpTR2xvYmFsQ29udGV4dFJlZgogd2Via2l0X3dlYl9mcmFtZV9n ZXRfZ2xvYmFsX2NvbnRleHQgKFdlYktpdFdlYkZyYW1lICAgICAgICpmcmFtZSk7CiAKK1dFQktJ VF9BUEkgdm9pZAord2Via2l0X3dlYl9mcmFtZV9wcmludCAgICAgICAgICAgICAgKFdlYktpdFdl YkZyYW1lICAgICAgICpmcmFtZSk7CisKK1dFQktJVF9BUEkgR3RrUHJpbnRPcGVyYXRpb25SZXN1 bHQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnRfZnVsbCAgICAgICAgIChXZWJLaXRXZWJGcmFtZSAg ICAgICAqZnJhbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR3RrUHJp bnRPcGVyYXRpb24gICAgKm9wZXJhdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBHdGtQcmludE9wZXJhdGlvbkFjdGlvbiBhY3Rpb24sCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgR0Vycm9yICAgICAgICAgICAgICAqKmVycm9yKTsKKwogR19F TkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IDc5 NmQ4NjYuLjc0ZmM2OWUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZp ZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0xMzgs NiArMTM4LDcgQEAgZW51bSB7CiAgICAgQ1VUX0NMSVBCT0FSRCwKICAgICBET1dOTE9BRF9SRVFV RVNURUQsCiAgICAgTU9WRV9DVVJTT1IsCisgICAgUFJJTlRfUkVRVUVTVEVELAogICAgIExBU1Rf U0lHTkFMCiB9OwogCkBAIC0xMzI2LDYgKzEzMjcsMzQgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dl Yl92aWV3X2NsYXNzX2luaXQoV2ViS2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAg ICAgICAgICBHX1RZUEVfTk9ORSwgMSwKICAgICAgICAgICAgIEdUS19UWVBFX01FTlUpOwogCisg ICAgLyoqCisgICAgICogV2ViS2l0V2ViVmlldzo6cHJpbnQtcmVxdWVzdGVkCisgICAgICogQHdl Yl92aWV3OiB0aGUgb2JqZWN0IGluIHdoaWNoIHRoZSBzaWduYWwgaXMgZW1pdHRlZAorICAgICAq IEB3ZWJfZnJhbWU6IHRoZSBmcmFtZSB0aGF0IGlzIHJlcXVlc3RpbmcgdG8gYmUgcHJpbnRlZAor ICAgICAqIEByZXR1cm46ICVUUlVFIGlmIHRoZSBwcmludCByZXF1ZXN0IGhhcyBiZWVuIGhhbmRs ZWQsICVGQUxTRSBpZgorICAgICAqIHRoZSBkZWZhdWx0IGhhbmRsZXIgc2hvdWxkIHJ1bgorICAg ICAqCisgICAgICogRW1pdHRlZCB3aGVuIHByaW50aW5nIGlzIHJlcXVlc3RlZCBieSB0aGUgZnJh bWUsIHVzdWFsbHkKKyAgICAgKiBiZWNhdXNlIG9mIGEgamF2YXNjcmlwdCBjYWxsLiBXaGlsZSBo YW5kbGluZyB0aGlzIHNpZ25hbCB5b3UKKyAgICAgKiBzaG91bGQgY2FsbCB3ZWJraXRfd2ViX2Zy YW1lX3ByaW50KCkgdG8gZG8gdGhlIGFjdHVhbCBwcmludGluZy4KKyAgICAgKgorICAgICAqIFRo ZSBkZWZhdWx0IGhhbmRsZXIgd2lsbCBwcmVzZW50IGEgcHJpbnQgZGlhbG9nIGFuZCBjYXJyeSBh CisgICAgICogcHJpbnQgb3BlcmF0aW9uLiBOb3RpY2UgdGhhdCB0aGlzIG1lYW5zIHRoYXQgaWYg eW91IGludGVuZCB0bworICAgICAqIGlnbm9yZSBhIHByaW50IHJlcXVlc3QgeW91IG11c3QgY29u bmVjdCB0byB0aGlzIHNpZ25hbCwgYW5kCisgICAgICogcmV0dXJuICVUUlVFLgorICAgICAqCisg ICAgICogU2luY2U6IDEuMS40CisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNb UFJJTlRfUkVRVUVTVEVEXSA9IGdfc2lnbmFsX25ldygicHJpbnQtcmVxdWVzdGVkIiwKKyAgICAg ICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCisgICAgICAgICAgICAoR1Np Z25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCisgICAgICAg ICAgICAwLAorICAgICAgICAgICAgTlVMTCwKKyAgICAgICAgICAgIE5VTEwsCisgICAgICAgICAg ICB3ZWJraXRfbWFyc2hhbF9CT09MRUFOX19PQkpFQ1QsCisgICAgICAgICAgICBHX1RZUEVfQk9P TEVBTiwgMSwKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX1dFQl9GUkFNRSk7CisKICAgICB3ZWJr aXRfd2ViX3ZpZXdfc2lnbmFsc1tTVEFUVVNfQkFSX1RFWFRfQ0hBTkdFRF0gPSBnX3NpZ25hbF9u ZXcoInN0YXR1cy1iYXItdGV4dC1jaGFuZ2VkIiwKICAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NM QVNTKHdlYlZpZXdDbGFzcyksCiAgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShHX1NJR05BTF9S VU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCg== 29227 2009-04-03 07:03:36 -0700 2009-04-06 14:40:59 -0700 unit tests for printing 2009-03-31-Gustavo-Noronha-Silva-gustavo.noronha-collabora.co.uk-.patch text/plain 4823 gustavo YzdkMGUwMWVlMGJiNmQ4ODIyNzc3MzdkZjM2ZDNmODRjYzNjZDE0NgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBlZGNmZmI2Li42 ZWQ2NjAzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtNSw2ICs1LDIxIEBACiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMjg5OAogICAgICAgICBbR1RLXSBuZWVkIHByb3BlciBBUEkg Zm9yIHByaW50aW5nCiAKKyAgICAgICAgQWRkZWQgc2ltcGxlIHByaW50aW5nIHVuaXQgdGVzdHMu CisKKyAgICAgICAgKiB0ZXN0cy90ZXN0d2ViZnJhbWUuYzoKKyAgICAgICAgKHByaW50X3JlcXVl c3RlZF9jYik6CisgICAgICAgIChwcmludF90aW1lb3V0KToKKyAgICAgICAgKHRlc3Rfd2Via2l0 X3dlYl9mcmFtZV9wcmludGluZyk6CisgICAgICAgIChtYWluKToKKworMjAwOS0wMy0zMSAgR3Vz dGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4OTgKKyAgICAgICAgW0dUS10gbmVlZCBw cm9wZXIgQVBJIGZvciBwcmludGluZworCiAgICAgICAgIEltcGxlbWVudCBwcm9wZXIgcHJpbnRp bmcgQVBJLCB1c2luZyB0aGUgR1RLKyBwcmludGluZyBBUEkuCiAKICAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwOgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay90ZXN0 cy90ZXN0d2ViZnJhbWUuYyBiL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdlYmZyYW1lLmMKaW5kZXgg ZTJkYTI5Yy4uZDI3ZGFjOCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2ViZnJh bWUuYworKysgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3R3ZWJmcmFtZS5jCkBAIC0xLDUgKzEsNiBA QAogLyoKICAqIENvcHlyaWdodCAoQykgMjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgor ICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCiAgKgogICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMK QEAgLTE3LDcgKzE4LDkgQEAKICAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgogICovCiAK KyNpbmNsdWRlIDx1bmlzdGQuaD4KICNpbmNsdWRlIDxnbGliLmg+CisjaW5jbHVkZSA8Z2xpYi9n c3RkaW8uaD4KICNpbmNsdWRlIDxndGsvZ3RrLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdC5o PgogCkBAIC02Miw2ICs2NSw4MyBAQCBzdGF0aWMgdm9pZCB0ZXN0X3dlYmtpdF93ZWJfZnJhbWVf bGlmZXRpbWUodm9pZCkKICAgICBnX29iamVjdF91bnJlZih3ZWJGcmFtZSk7CiB9CiAKK3N0YXRp YyBnYm9vbGVhbiBwcmludF9yZXF1ZXN0ZWRfY2IoV2ViS2l0V2ViVmlldyogd2ViVmlldywgV2Vi S2l0V2ViRnJhbWUqIHdlYkZyYW1lLCBHTWFpbkxvb3AqIGxvb3ApCit7CisgICAgZ19vYmplY3Rf c2V0X2RhdGEoR19PQkpFQ1Qod2ViVmlldyksICJzaWduYWwtaGFuZGxlZCIsIEdJTlRfVE9fUE9J TlRFUihUUlVFKSk7CisgICAgZ19tYWluX2xvb3BfcXVpdChsb29wKTsKKyAgICByZXR1cm4gVFJV RTsKK30KKworc3RhdGljIHZvaWQgcHJpbnRfdGltZW91dChHTWFpbkxvb3AqIGxvb3ApCit7Cisg ICAgaWYgKGdfbWFpbl9sb29wX2lzX3J1bm5pbmcobG9vcCkpCisgICAgICAgIGdfbWFpbl9sb29w X3F1aXQobG9vcCk7Cit9CisKK3N0YXRpYyB2b2lkIHRlc3Rfd2Via2l0X3dlYl9mcmFtZV9wcmlu dGluZyh2b2lkKQoreworICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXc7CisKKyAgICB3ZWJWaWV3 ID0gV0VCS0lUX1dFQl9WSUVXKHdlYmtpdF93ZWJfdmlld19uZXcoKSk7CisgICAgZ19vYmplY3Rf cmVmX3Npbmsod2ViVmlldyk7CisgICAgZ19hc3NlcnRfY21waW50KEdfT0JKRUNUKHdlYlZpZXcp LT5yZWZfY291bnQsID09LCAxKTsKKworICAgIHdlYmtpdF93ZWJfdmlld19sb2FkX3N0cmluZyh3 ZWJWaWV3LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiPGh0bWw+PGJvZHk+PGgx PldlYktpdEdUSyshPC9oMT48L2JvZHk+PC9odG1sPiIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICJ0ZXh0L2h0bWwiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi dXRmLTgiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZmlsZTovLyIpOworCisg ICAgR01haW5Mb29wKiBsb29wID0gZ19tYWluX2xvb3BfbmV3KE5VTEwsIFRSVUUpOworCisgICAg Ly8gRG9lcyBqYXZhc2NyaXB0IHByaW50KCkgd29yayBjb3JyZWN0bHk/CisgICAgZ19zaWduYWxf Y29ubmVjdCh3ZWJWaWV3LCAicHJpbnQtcmVxdWVzdGVkIiwKKyAgICAgICAgICAgICAgICAgICAg IEdfQ0FMTEJBQ0socHJpbnRfcmVxdWVzdGVkX2NiKSwKKyAgICAgICAgICAgICAgICAgICAgIGxv b3ApOworCisgICAgZ19vYmplY3Rfc2V0X2RhdGEoR19PQkpFQ1Qod2ViVmlldyksICJzaWduYWwt aGFuZGxlZCIsIEdJTlRfVE9fUE9JTlRFUihGQUxTRSkpOworICAgIHdlYmtpdF93ZWJfdmlld19l eGVjdXRlX3NjcmlwdCAod2ViVmlldywgInByaW50KCk7Iik7CisKKyAgICAvLyBHaXZlIGphdmFz Y3JpcHRjb3JlIHNvbWUgdGltZSB0byBwcm9jZXNzIHRoZSBwcmludCByZXF1ZXN0LCBidXQKKyAg ICAvLyBwcmVwYXJlIGEgdGltZW91dCB0byBhdm9pZCBpdCBydW5uaW5nIGZvcmV2ZXIgaW4gY2Fz ZSB0aGUgc2lnbmFsIGlzCisgICAgLy8gbmV2ZXIgZW1pdHRlZC4KKyAgICBnX3RpbWVvdXRfYWRk KDEwMDAsIChHU291cmNlRnVuYylwcmludF90aW1lb3V0LCBsb29wKTsKKyAgICBnX21haW5fbG9v cF9ydW4obG9vcCk7CisKKyAgICBnX2Fzc2VydF9jbXBpbnQoR1BPSU5URVJfVE9fSU5UKGdfb2Jq ZWN0X2dldF9kYXRhKEdfT0JKRUNUKHdlYlZpZXcpLCAic2lnbmFsLWhhbmRsZWQiKSksID09LCBU UlVFKTsKKworICAgIC8vIERvZXMgcHJpbnRpbmcgZGlyZWN0bHkgdG8gYSBmaWxlPworICAgIEdF cnJvciAqZXJyb3IgPSBOVUxMOworICAgIGdjaGFyKiB0ZW1wb3JhcnlGaWxlbmFtZSA9IE5VTEw7 CisgICAgZ2ludCBmZCA9IGdfZmlsZV9vcGVuX3RtcCAoIndlYmtpdC10ZXN0d2ViZnJhbWUtWFhY WFhYIiwgJnRlbXBvcmFyeUZpbGVuYW1lLCAmZXJyb3IpOworICAgIGNsb3NlKGZkKTsKKworICAg IC8vIFdlIGRlbGV0ZSB0aGUgZmlsZSwgc28gdGhhdCB3ZSBjYW4gZWFzaWx5IGZpZ3VyZSBvdXQg dGhhdCB0aGUKKyAgICAvLyBmaWxlIGdvdCBwcmludGVkOworICAgIGlmIChlcnJvciB8fCAoZ191 bmxpbmsodGVtcG9yYXJ5RmlsZW5hbWUpID09IC0xKSkgeworICAgICAgICBnX2NyaXRpY2FsKCJG YWlsZWQgdG8gb3BlbiBhIHRlbXBvcmFyeSBmaWxlIGZvciB3cml0aW5nOiAlcy4iLCBlcnJvci0+ bWVzc2FnZSk7CisgICAgICAgIGdfZXJyb3JfZnJlZShlcnJvcik7CisgICAgICAgIGdvdG8gY2xl YW51cDsKKyAgICB9CisKKyAgICBXZWJLaXRXZWJGcmFtZSogd2ViRnJhbWUgPSB3ZWJraXRfd2Vi X3ZpZXdfZ2V0X21haW5fZnJhbWUod2ViVmlldyk7CisgICAgR3RrUHJpbnRPcGVyYXRpb24qIG9w ZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRpb25fbmV3KCk7CisgICAgR3RrUHJpbnRPcGVyYXRp b25BY3Rpb24gYWN0aW9uID0gR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05fRVhQT1JUOworICAg IEd0a1ByaW50T3BlcmF0aW9uUmVzdWx0IHJlc3VsdDsKKworICAgIGd0a19wcmludF9vcGVyYXRp b25fc2V0X2V4cG9ydF9maWxlbmFtZShvcGVyYXRpb24sIHRlbXBvcmFyeUZpbGVuYW1lKTsKKyAg ICByZXN1bHQgPSB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGwgKHdlYkZyYW1lLCBvcGVyYXRp b24sIGFjdGlvbiwgTlVMTCk7CisKKyAgICBnX2Fzc2VydF9jbXBpbnQocmVzdWx0LCA9PSwgR1RL X1BSSU5UX09QRVJBVElPTl9SRVNVTFRfQVBQTFkpOworICAgIGdfYXNzZXJ0X2NtcGludChnX2Zp bGVfdGVzdCh0ZW1wb3JhcnlGaWxlbmFtZSwgR19GSUxFX1RFU1RfSVNfUkVHVUxBUiksID09LCBU UlVFKTsKKworICAgIGdfdW5saW5rKHRlbXBvcmFyeUZpbGVuYW1lKTsKKyAgICBnX29iamVjdF91 bnJlZihvcGVyYXRpb24pOworY2xlYW51cDoKKyAgICBnX29iamVjdF91bnJlZih3ZWJWaWV3KTsK KyAgICBnX2ZyZWUodGVtcG9yYXJ5RmlsZW5hbWUpOworfQorCiBpbnQgbWFpbihpbnQgYXJnYywg Y2hhcioqIGFyZ3YpCiB7CiAgICAgZ190aHJlYWRfaW5pdChOVUxMKTsKQEAgLTcwLDYgKzE1MCw3 IEBAIGludCBtYWluKGludCBhcmdjLCBjaGFyKiogYXJndikKICAgICBnX3Rlc3RfYnVnX2Jhc2Uo Imh0dHBzOi8vYnVncy53ZWJraXQub3JnLyIpOwogICAgIGdfdGVzdF9hZGRfZnVuYygiL3dlYmtp dC93ZWJ2aWV3L2NyZWF0ZV9kZXN0cm95IiwgdGVzdF93ZWJraXRfd2ViX2ZyYW1lX2NyZWF0ZV9k ZXN0cm95KTsKICAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvd2ViZnJhbWUvbGlmZXRpbWUi LCB0ZXN0X3dlYmtpdF93ZWJfZnJhbWVfbGlmZXRpbWUpOworICAgIGdfdGVzdF9hZGRfZnVuYygi L3dlYmtpdC93ZWJ2aWV3L3ByaW50aW5nIiwgdGVzdF93ZWJraXRfd2ViX2ZyYW1lX3ByaW50aW5n KTsKICAgICByZXR1cm4gZ190ZXN0X3J1biAoKTsKIH0KIAo= 29256 2009-04-04 12:13:40 -0700 2009-04-04 12:15:23 -0700 When a download is requested by an ongoing request, use the already When-a-download-is-requested-by-an-ongoing-request-use-the-already.patch text/plain 6488 gustavo NDYwN2U3NjkwNDEwNDgwZDA1MjQ4ZTU5OWU4YmYzODc3NmE0NDIyZApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBhMGVjNmI2Li5h ZTIxMjIwIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtNSw2ICs1LDI2IEBACiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yNDc4NgogICAgICAgICBXZWJLaXREb3dubG9hZCBzb21ldGlt ZXMgc3VnZ2VzdHMgcGVjdWxpYXIgZmlsZW5hbWVzCiAKKyAgICAgICAgV2hlbiBhIGRvd25sb2Fk IGlzIHJlcXVlc3RlZCBieSBhbiBvbmdvaW5nIHJlcXVlc3QsIHVzZSB0aGUgYWxyZWFkeQorICAg ICAgICBwcm92aWRlZCByZXNwb25zZSB0byBzZXQgdGhlIHN1Z2dlc3RlZCBmaWxlbmFtZSBmb3Ig dGhlIFdlYktpdERvd25sb2FkCisgICAgICAgIG9iamVjdCwgaWYgYXZhaWxhYmxlLgorCisgICAg ICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwOgorICAgICAgICAo V2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZG93bmxvYWQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRkb3dubG9hZC5jcHA6CisgICAgICAgIChfV2ViS2l0RG93bmxvYWRQcml2YXRlOjp3ZWJr aXRfZG93bmxvYWRfc2V0X3Byb3BlcnR5KToKKyAgICAgICAgKF9XZWJLaXREb3dubG9hZFByaXZh dGU6OndlYmtpdF9kb3dubG9hZF9nZXRfc3VnZ2VzdGVkX2ZpbGVuYW1lKToKKyAgICAgICAgKF9X ZWJLaXREb3dubG9hZFByaXZhdGU6OndlYmtpdF9kb3dubG9hZF9zZXRfc3VnZ2VzdGVkX2ZpbGVu YW1lKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5oOgorICAgICAgICAqIHdlYmtp dC93ZWJraXR3ZWJ2aWV3LmNwcDoKKworMjAwOS0wNC0wNCAgR3VzdGF2byBOb3JvbmhhIFNpbHZh ICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjQ3ODYKKyAgICAgICAgV2ViS2l0RG93bmxvYWQgc29tZXRpbWVzIHN1Z2dl c3RzIHBlY3VsaWFyIGZpbGVuYW1lcworCiAgICAgICAgIFJlZmFjdG9yIHRoZSBlbWlzc2lvbiBv ZiB0aGUgZG93bmxvYWQtcmVxdWVzdGVkIHNpZ25hbCBzbyB0aGF0IHdlCiAgICAgICAgIGhhdmUg bGVzcyBjb2RlIGR1cGxpY2F0aW9uLgogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBv cnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IDVlYTE2MDEuLjVlNmU3ZDIgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3Bw CisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3Bw CkBAIC04MjAsMTMgKzgyMCwxOCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERp ZEZhaWxMb2FkKGNvbnN0IFJlc291cmNlRXJyb3ImKQogICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFt ZShtX2ZyYW1lLCAibG9hZC1kb25lIiwgZmFsc2UpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xp ZW50Ojpkb3dubG9hZChSZXNvdXJjZUhhbmRsZSogaGFuZGxlLCBjb25zdCBSZXNvdXJjZVJlcXVl c3QmIHJlcXVlc3QsIGNvbnN0IFJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFJlc291cmNlUmVzcG9u c2UmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZG93bmxvYWQoUmVzb3VyY2VIYW5kbGUqIGhh bmRsZSwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBSZXNvdXJjZVJlcXVl c3QmLCBjb25zdCBSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSkKIHsKICAgICAvLyBGSVhNRTog V2UgY291bGQgcmV1c2UgdGhlIHNhbWUgaGFuZGxlIGhlcmUsIGJ1dCB3aGVuIEkgdHJpZWQKICAg ICAvLyBpbXBsZW1lbnRpbmcgdGhhdCB0aGUgbWFpbiBsb2FkIHdvdWxkIGZhaWwgYW5kIHN0b3As IHNvIEkgaGF2ZQogICAgIC8vIHNpbXBsaWZpZWQgdGhpcyBjYXNlIGZvciBub3cuCiAgICAgaGFu ZGxlLT5jYW5jZWwoKTsKLSAgICBzdGFydERvd25sb2FkKHJlcXVlc3QpOworCisgICAgV2ViS2l0 TmV0d29ya1JlcXVlc3QqIG5ldHdvcmtSZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9u ZXcocmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBXZWJLaXRXZWJW aWV3KiB2aWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKKworICAgIHdlYmtpdF93ZWJf dmlld19yZXF1ZXN0X2Rvd25sb2FkKHZpZXcsIG5ldHdvcmtSZXF1ZXN0LCByZXNwb25zZSk7Cisg ICAgZ19vYmplY3RfdW5yZWYobmV0d29ya1JlcXVlc3QpOwogfQogCiBSZXNvdXJjZUVycm9yIEZy YW1lTG9hZGVyQ2xpZW50OjpjYW5jZWxsZWRFcnJvcihjb25zdCBSZXNvdXJjZVJlcXVlc3QmKQpk aWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwIGIvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuY3BwCmluZGV4IDdlMzk5NjkuLjI0OWFmMmMgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNwcAorKysgYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRkb3dubG9hZC5jcHAKQEAgLTE4NSwxNyArMTg1LDEwIEBAIHN0 YXRpYyB2b2lkIHdlYmtpdF9kb3dubG9hZF9zZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBn dWludCBwcm9wX2lkLCBjb25zdCBHCiB7CiAgICAgV2ViS2l0RG93bmxvYWQqIGRvd25sb2FkID0g V0VCS0lUX0RPV05MT0FEKG9iamVjdCk7CiAgICAgV2ViS2l0RG93bmxvYWRQcml2YXRlKiBwcml2 ID0gZG93bmxvYWQtPnByaXY7Ci0gICAgS1VSTCB1cmw7CiAKICAgICBzd2l0Y2gocHJvcF9pZCkg ewogICAgIGNhc2UgUFJPUF9ORVRXT1JLX1JFUVVFU1Q6CiAgICAgICAgIHByaXYtPm5ldHdvcmtS ZXF1ZXN0ID0gV0VCS0lUX05FVFdPUktfUkVRVUVTVChnX3ZhbHVlX2R1cF9vYmplY3QodmFsdWUp KTsKLSAgICAgICAgLy8gVGhpcyBpcyBzYWZlIGFzIG5ldHdvcmstcmVxdWVzdCBpcyBhIGNvbnN0 cnVjdCBvbmx5IHByb3BlcnR5IGFuZAotICAgICAgICAvLyBzdWdnZXN0ZWRGaWxlbmFtZSBpcyBp bml0aWFsbHkgbnVsbC4KLSAgICAgICAgdXJsID0gS1VSTChLVVJMKCksIHdlYmtpdF9uZXR3b3Jr X3JlcXVlc3RfZ2V0X3VyaShwcml2LT5uZXR3b3JrUmVxdWVzdCkpOwotICAgICAgICB1cmwuc2V0 UXVlcnkoU3RyaW5nKCkpOwotICAgICAgICB1cmwucmVtb3ZlUmVmKCk7Ci0gICAgICAgIHByaXYt PnN1Z2dlc3RlZEZpbGVuYW1lID0gZ19zdHJkdXAoZGVjb2RlVVJMRXNjYXBlU2VxdWVuY2VzKHVy bC5sYXN0UGF0aENvbXBvbmVudCgpKS51dGY4KCkuZGF0YSgpKTsKICAgICAgICAgYnJlYWs7CiAg ICAgY2FzZSBQUk9QX0RFU1RJTkFUSU9OX1VSSToKICAgICAgICAgd2Via2l0X2Rvd25sb2FkX3Nl dF9kZXN0aW5hdGlvbl91cmkoZG93bmxvYWQsIGdfdmFsdWVfZ2V0X3N0cmluZyh2YWx1ZSkpOwpA QCAtNTMzLDkgKzUyNiwyNSBAQCBjb25zdCBnY2hhciogd2Via2l0X2Rvd25sb2FkX2dldF9zdWdn ZXN0ZWRfZmlsZW5hbWUoV2ViS2l0RG93bmxvYWQqIGRvd25sb2FkKQogICAgIGdfcmV0dXJuX3Zh bF9pZl9mYWlsKFdFQktJVF9JU19ET1dOTE9BRChkb3dubG9hZCksIE5VTEwpOwogCiAgICAgV2Vi S2l0RG93bmxvYWRQcml2YXRlKiBwcml2ID0gZG93bmxvYWQtPnByaXY7CisgICAgaWYgKHByaXYt PnN1Z2dlc3RlZEZpbGVuYW1lKQorICAgICAgICByZXR1cm4gcHJpdi0+c3VnZ2VzdGVkRmlsZW5h bWU7CisKKyAgICBLVVJMIHVybCA9IEtVUkwoS1VSTCgpLCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF91cmkocHJpdi0+bmV0d29ya1JlcXVlc3QpKTsKKyAgICB1cmwuc2V0UXVlcnkoU3RyaW5n KCkpOworICAgIHVybC5yZW1vdmVSZWYoKTsKKyAgICBwcml2LT5zdWdnZXN0ZWRGaWxlbmFtZSA9 IGdfc3RyZHVwKGRlY29kZVVSTEVzY2FwZVNlcXVlbmNlcyh1cmwubGFzdFBhdGhDb21wb25lbnQo KSkudXRmOCgpLmRhdGEoKSk7CiAgICAgcmV0dXJuIHByaXYtPnN1Z2dlc3RlZEZpbGVuYW1lOwog fQogCisvLyBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKK3ZvaWQgd2Via2l0X2Rvd25sb2FkX3NldF9z dWdnZXN0ZWRfZmlsZW5hbWUoV2ViS2l0RG93bmxvYWQqIGRvd25sb2FkLCBjb25zdCBnY2hhciog c3VnZ2VzdGVkRmlsZW5hbWUpCit7CisgICAgV2ViS2l0RG93bmxvYWRQcml2YXRlKiBwcml2ID0g ZG93bmxvYWQtPnByaXY7CisgICAgZ19mcmVlKHByaXYtPnN1Z2dlc3RlZEZpbGVuYW1lKTsKKyAg ICBwcml2LT5zdWdnZXN0ZWRGaWxlbmFtZSA9IGdfc3RyZHVwKHN1Z2dlc3RlZEZpbGVuYW1lKTsK K30KKworCiAvKioKICAqIHdlYmtpdF9kb3dubG9hZF9nZXRfZGVzdGluYXRpb25fdXJpOgogICog QGRvd25sb2FkOiB0aGUgI1dlYktpdERvd25sb2FkCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgK aW5kZXggZDgyMWM1ZS4uNDI5YjQ4OSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAt MTYwLDcgKzE2MCwxMCBAQCBleHRlcm4gIkMiIHsKICAgICB3ZWJraXRfd2ViX3ZpZXdfbm90aWZ5 X3JlYWR5IChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldyk7CiAKICAgICB2b2lkCi0gICAgd2Via2l0 X3dlYl92aWV3X3JlcXVlc3RfZG93bmxvYWQoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcsIFdlYktp dE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsKKyAgICB3ZWJraXRfd2ViX3ZpZXdfcmVxdWVzdF9k b3dubG9hZChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldywgV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmIHJlc3BvbnNlID0gV2ViQ29y ZTo6UmVzb3VyY2VSZXNwb25zZSgpKTsKKworICAgIHZvaWQKKyAgICB3ZWJraXRfZG93bmxvYWRf c2V0X3N1Z2dlc3RlZF9maWxlbmFtZShXZWJLaXREb3dubG9hZCogZG93bmxvYWQsIGNvbnN0IGdj aGFyKiBzdWdnZXN0ZWRGaWxlbmFtZSk7CiAKICAgICBXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbioK ICAgICB3ZWJraXRfd2ViX3BvbGljeV9kZWNpc2lvbl9uZXcgKFdlYktpdFdlYkZyYW1lKiwgV2Vi Q29yZTo6RnJhbWVQb2xpY3lGdW5jdGlvbik7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw CmluZGV4IDJmODc3ZDMuLjY1NGU3MTcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw CkBAIC0yMDQ4LDEzICsyMDQ4LDE4IEBAIHZvaWQgd2Via2l0X3dlYl92aWV3X25vdGlmeV9yZWFk eShXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQogICAgIGdfc2lnbmFsX2VtaXQod2ViVmlldywgd2Vi a2l0X3dlYl92aWV3X3NpZ25hbHNbV0VCX1ZJRVdfUkVBRFldLCAwLCAmaXNIYW5kbGVkKTsKIH0K IAotdm9pZCB3ZWJraXRfd2ViX3ZpZXdfcmVxdWVzdF9kb3dubG9hZChXZWJLaXRXZWJWaWV3KiB3 ZWJWaWV3LCBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCkKK3ZvaWQgd2Via2l0X3dlYl92 aWV3X3JlcXVlc3RfZG93bmxvYWQoV2ViS2l0V2ViVmlldyogd2ViVmlldywgV2ViS2l0TmV0d29y a1JlcXVlc3QqIHJlcXVlc3QsIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmIHJlc3BvbnNlKQogewog ICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9WSUVXKHdlYlZpZXcpKTsKIAogICAg IFdlYktpdERvd25sb2FkKiBkb3dubG9hZCA9IHdlYmtpdF9kb3dubG9hZF9uZXcocmVxdWVzdCk7 CiAgICAgZ19vYmplY3RfdW5yZWYocmVxdWVzdCk7CiAKKyAgICBpZiAoIXJlc3BvbnNlLmlzTnVs bCgpICYmICFyZXNwb25zZS5zdWdnZXN0ZWRGaWxlbmFtZSgpLmlzRW1wdHkoKSkgeworICAgICAg ICBnX2RlYnVnKCJzdWdnZXN0ZWQgZmlsZW5hbWUgZXhpc3RzISIpOworICAgICAgICB3ZWJraXRf ZG93bmxvYWRfc2V0X3N1Z2dlc3RlZF9maWxlbmFtZShkb3dubG9hZCwgcmVzcG9uc2Uuc3VnZ2Vz dGVkRmlsZW5hbWUoKS51dGY4KCkuZGF0YSgpKTsKKyAgICB9CisKICAgICBnYm9vbGVhbiBoYW5k bGVkOwogICAgIGdfc2lnbmFsX2VtaXQod2ViVmlldywgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNb RE9XTkxPQURfUkVRVUVTVEVEXSwgMCwgZG93bmxvYWQsICZoYW5kbGVkKTsKIAo= 29288 2009-04-06 14:39:09 -0700 2009-04-12 16:04:03 -0700 proposed printing API 2009-04-06-Gustavo-Noronha-Silva-gns-gnome.org-.patch text/plain 9911 gustavo NzM4NjUwY2VjYzQ1YjU2Njc2NmI5YWViYmJmZjM3MGQ0ODFjY2FlZQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBlNzFlNmJjLi4y ZDM3NjhkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDA5LTA0LTA2ICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y Mjg5OAorICAgICAgICBbR1RLXSBuZWVkIHByb3BlciBBUEkgZm9yIHByaW50aW5nCisKKyAgICAg ICAgSW1wbGVtZW50IHByb3BlciBwcmludGluZyBBUEksIHVzaW5nIHRoZSBHVEsrIHByaW50aW5n IEFQSS4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OkNocm9tZUNsaWVudDo6cHJpbnQpOgorICAgICAgICAqIHdlYmtpdC93 ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAg ICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJhbWUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0 d2Vidmlldy5jcHA6CisKIDIwMDktMDQtMDYgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rh dm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkg U2FtIFdlaW5pZy4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21l Q2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3Rr LmNwcAppbmRleCBiYjgwOTFhLi41ZTNmZWFkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNv cmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAKKysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3Vw cG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwCkBAIC00MDQsNyArNDA0LDE0IEBAIHZvaWQgQ2hyb21l Q2xpZW50OjpzZXRUb29sVGlwKGNvbnN0IFN0cmluZyYgdG9vbFRpcCkKIAogdm9pZCBDaHJvbWVD bGllbnQ6OnByaW50KEZyYW1lKiBmcmFtZSkKIHsKLSAgICB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50 KGtpdChmcmFtZSkpOworICAgIFdlYktpdFdlYkZyYW1lKiB3ZWJGcmFtZSA9IGtpdChmcmFtZSk7 CisgICAgZ2Jvb2xlYW4gaXNIYW5kbGVkID0gZmFsc2U7CisgICAgZ19zaWduYWxfZW1pdF9ieV9u YW1lKG1fd2ViVmlldywgInByaW50LXJlcXVlc3RlZCIsIHdlYkZyYW1lLCAmaXNIYW5kbGVkKTsK KworICAgIGlmIChpc0hhbmRsZWQpCisgICAgICAgIHJldHVybjsKKworICAgIHdlYmtpdF93ZWJf ZnJhbWVfcHJpbnQod2ViRnJhbWUpOwogfQogCiB2b2lkIENocm9tZUNsaWVudDo6ZXhjZWVkZWRE YXRhYmFzZVF1b3RhKEZyYW1lKiBmcmFtZSwgY29uc3QgU3RyaW5nJikKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHByaXZhdGUuaAppbmRleCAwYjgzYTExLi44MjMwYjg2IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5oCkBAIC0xNzYsOSArMTc2LDYgQEAgZXh0ZXJuICJDIiB7CiAgICAgV0VCS0lUX0FQSSBn Y2hhcioKICAgICB3ZWJraXRfd2ViX2ZyYW1lX2dldF9pbm5lcl90ZXh0IChXZWJLaXRXZWJGcmFt ZSogZnJhbWUpOwogCi0gICAgV0VCS0lUX0FQSSB2b2lkCi0gICAgd2Via2l0X3dlYl9mcmFtZV9w cmludCAoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKTsKLQogICAgIFdFQktJVF9BUEkgZ2NoYXIqCiAg ICAgd2Via2l0X3dlYl9mcmFtZV9kdW1wX3JlbmRlcl90cmVlIChXZWJLaXRXZWJGcmFtZSogZnJh bWUpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKaW5kZXggZDNjYTMxZC4uN2Jh MjJmNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuY3BwCisr KyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcApAQCAtNiw2ICs2LDcgQEAK ICAqIENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRkLgogICogQ29weXJpZ2h0IChDKSAy MDA4IE51YW50aSBMdGQuCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDkgSmFuIEFsb256byA8am1hbG9u em9AZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2 YSA8Z25zQGdub21lLm9yZz4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtNjExLDcgKzYxMiw3IEBA IGdjaGFyKiB3ZWJraXRfd2ViX2ZyYW1lX2R1bXBfcmVuZGVyX3RyZWUoV2ViS2l0V2ViRnJhbWUq IGZyYW1lKQogICAgIHJldHVybiBnX3N0cmR1cChzdHJpbmcudXRmOCgpLmRhdGEoKSk7CiB9CiAK LXN0YXRpYyB2b2lkIGJlZ2luX3ByaW50KEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRD b250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCitzdGF0aWMgdm9pZCBiZWdpbl9w cmludF9jYWxsYmFjayhHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29udGV4dCogY29u dGV4dCwgZ3BvaW50ZXIgdXNlcl9kYXRhKQogewogICAgIFByaW50Q29udGV4dCogcHJpbnRDb250 ZXh0ID0gcmVpbnRlcnByZXRfY2FzdDxQcmludENvbnRleHQqPih1c2VyX2RhdGEpOwogCkBAIC02 MjksNyArNjMwLDcgQEAgc3RhdGljIHZvaWQgYmVnaW5fcHJpbnQoR3RrUHJpbnRPcGVyYXRpb24q IG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdwb2ludGUKICAgICBndGtfcHJpbnRfb3Bl cmF0aW9uX3NldF9uX3BhZ2VzKG9wLCBwcmludENvbnRleHQtPnBhZ2VDb3VudCgpKTsKIH0KIAot c3RhdGljIHZvaWQgZHJhd19wYWdlKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250 ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2VfbnIsIGdwb2ludGVyIHVzZXJfZGF0YSkKK3N0YXRpYyB2 b2lkIGRyYXdfcGFnZV9jYWxsYmFjayhHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29u dGV4dCogY29udGV4dCwgZ2ludCBwYWdlX25yLCBncG9pbnRlciB1c2VyX2RhdGEpCiB7CiAgICAg UHJpbnRDb250ZXh0KiBwcmludENvbnRleHQgPSByZWludGVycHJldF9jYXN0PFByaW50Q29udGV4 dCo+KHVzZXJfZGF0YSk7CiAKQEAgLTYzOSwzNCArNjQwLDcyIEBAIHN0YXRpYyB2b2lkIGRyYXdf cGFnZShHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29udGV4dCogY29udGV4dCwgZ2lu dCBwYWdlCiAgICAgcHJpbnRDb250ZXh0LT5zcG9vbFBhZ2UoY3R4LCBwYWdlX25yLCB3aWR0aCk7 CiB9CiAKLXN0YXRpYyB2b2lkIGVuZF9wcmludChHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1By aW50Q29udGV4dCogY29udGV4dCwgZ3BvaW50ZXIgdXNlcl9kYXRhKQorc3RhdGljIHZvaWQgZW5k X3ByaW50X2NhbGxiYWNrKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBj b250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCiB7CiAgICAgUHJpbnRDb250ZXh0KiBwcmludENv bnRleHQgPSByZWludGVycHJldF9jYXN0PFByaW50Q29udGV4dCo+KHVzZXJfZGF0YSk7CiAgICAg cHJpbnRDb250ZXh0LT5lbmQoKTsKIH0KIAotdm9pZCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50KFdl YktpdFdlYkZyYW1lKiBmcmFtZSkKKy8qKgorICogd2Via2l0X3dlYl9mcmFtZV9wcmludF9mdWxs OgorICogQGZyYW1lOiBhICNXZWJLaXRXZWJGcmFtZSB0byBiZSBwcmludGVkCisgKiBAb3BlcmF0 aW9uOiB0aGUgI0d0a1ByaW50T3BlcmF0aW9uIHRvIGJlIGNhcnJpZWQKKyAqIEBhY3Rpb246IHRo ZSAjR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gdG8gYmUgcGVyZm9ybWVkCisgKiBAZXJyb3I6ICNH RXJyb3IgZm9yIGVycm9yIHJldHVybgorICoKKyAqIFByaW50cyB0aGUgZ2l2ZW4gI1dlYktpdEZy YW1lLCB1c2luZyB0aGUgZ2l2ZW4gI0d0a1ByaW50T3BlcmF0aW9uCisgKiBhbmQgI0d0a1ByaW50 T3BlcmF0aW9uQWN0aW9uLiBUaGlzIGZ1bmN0aW9uIHdyYXBzIGEgY2FsbCB0bworICogZ3RrX3By aW50X29wZXJhdGlvbl9ydW4oKSBmb3IgcHJpbnRpbmcgdGhlIGNvbnRlbnRzIG9mIHRoZQorICog I1dlYktpdFdlYkZyYW1lLgorICoKKyAqIFNpbmNlOiAxLjEuNQorICovCitHdGtQcmludE9wZXJh dGlvblJlc3VsdCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGwoV2ViS2l0V2ViRnJhbWUqIGZy YW1lLCBHdGtQcmludE9wZXJhdGlvbiogb3BlcmF0aW9uLCBHdGtQcmludE9wZXJhdGlvbkFjdGlv biBhY3Rpb24sIEdFcnJvcioqIGVycm9yKQogeworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdF QktJVF9JU19XRUJfRlJBTUUoZnJhbWUpLCBHVEtfUFJJTlRfT1BFUkFUSU9OX1JFU1VMVF9FUlJP Uik7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoR1RLX0lTX1BSSU5UX09QRVJBVElPTihvcGVy YXRpb24pLCBHVEtfUFJJTlRfT1BFUkFUSU9OX1JFU1VMVF9FUlJPUik7CisKICAgICBHdGtXaWRn ZXQqIHRvcExldmVsID0gZ3RrX3dpZGdldF9nZXRfdG9wbGV2ZWwoR1RLX1dJREdFVCh3ZWJraXRf d2ViX2ZyYW1lX2dldF93ZWJfdmlldyhmcmFtZSkpKTsKICAgICBpZiAoIUdUS19XSURHRVRfVE9Q TEVWRUwodG9wTGV2ZWwpKQogICAgICAgICB0b3BMZXZlbCA9IE5VTEw7CiAKICAgICBGcmFtZSog Y29yZUZyYW1lID0gY29yZShmcmFtZSk7CiAgICAgaWYgKCFjb3JlRnJhbWUpCi0gICAgICAgIHJl dHVybjsKKyAgICAgICAgcmV0dXJuIEdUS19QUklOVF9PUEVSQVRJT05fUkVTVUxUX0VSUk9SOwog CiAgICAgUHJpbnRDb250ZXh0IHByaW50Q29udGV4dChjb3JlRnJhbWUpOwogCi0gICAgR3RrUHJp bnRPcGVyYXRpb24qIG9wID0gZ3RrX3ByaW50X29wZXJhdGlvbl9uZXcoKTsKLSAgICBnX3NpZ25h bF9jb25uZWN0KG9wLCAiYmVnaW4tcHJpbnQiLCBHX0NBTExCQUNLKGJlZ2luX3ByaW50KSwgJnBy aW50Q29udGV4dCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChvcCwgImRyYXctcGFnZSIsIEdfQ0FM TEJBQ0soZHJhd19wYWdlKSwgJnByaW50Q29udGV4dCk7Ci0gICAgZ19zaWduYWxfY29ubmVjdChv cCwgImVuZC1wcmludCIsIEdfQ0FMTEJBQ0soZW5kX3ByaW50KSwgJnByaW50Q29udGV4dCk7Ci0g ICAgR0Vycm9yICplcnJvciA9IE5VTEw7Ci0gICAgZ3RrX3ByaW50X29wZXJhdGlvbl9ydW4ob3As IEdUS19QUklOVF9PUEVSQVRJT05fQUNUSU9OX1BSSU5UX0RJQUxPRywgR1RLX1dJTkRPVyh0b3BM ZXZlbCksICZlcnJvcik7Ci0gICAgZ19vYmplY3RfdW5yZWYob3ApOworICAgIGdfc2lnbmFsX2Nv bm5lY3Qob3BlcmF0aW9uLCAiYmVnaW4tcHJpbnQiLCBHX0NBTExCQUNLKGJlZ2luX3ByaW50X2Nh bGxiYWNrKSwgJnByaW50Q29udGV4dCk7CisgICAgZ19zaWduYWxfY29ubmVjdChvcGVyYXRpb24s ICJkcmF3LXBhZ2UiLCBHX0NBTExCQUNLKGRyYXdfcGFnZV9jYWxsYmFjayksICZwcmludENvbnRl eHQpOworICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3BlcmF0aW9uLCAiZW5kLXByaW50IiwgR19DQUxM QkFDSyhlbmRfcHJpbnRfY2FsbGJhY2spLCAmcHJpbnRDb250ZXh0KTsKKworICAgIHJldHVybiBn dGtfcHJpbnRfb3BlcmF0aW9uX3J1bihvcGVyYXRpb24sIGFjdGlvbiwgR1RLX1dJTkRPVyh0b3BM ZXZlbCksIGVycm9yKTsKK30KKworLyoqCisgKiB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50OgorICog QGZyYW1lOiBhICNXZWJLaXRXZWJGcmFtZQorICoKKyAqIFByaW50cyB0aGUgZ2l2ZW4gI1dlYktp dEZyYW1lLCBieSBwcmVzZW50aW5nIGEgcHJpbnQgZGlhbG9nIHRvIHRoZQorICogdXNlci4gSWYg eW91IG5lZWQgbW9yZSBjb250cm9sIG92ZXIgdGhlIHByaW50aW5nIHByb2Nlc3MsIHNlZQorICog d2Via2l0X3dlYl9mcmFtZV9wcmludF9mdWxsKCkuCisgKgorICogU2luY2U6IDEuMS41CisgKi8K K3ZvaWQgd2Via2l0X3dlYl9mcmFtZV9wcmludChXZWJLaXRXZWJGcmFtZSogZnJhbWUpCit7Cisg ICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfV0VCX0ZSQU1FKGZyYW1lKSk7CisKKyAgICBX ZWJLaXRXZWJGcmFtZVByaXZhdGUqIHByaXYgPSBmcmFtZS0+cHJpdjsKKyAgICBHdGtQcmludE9w ZXJhdGlvbiogb3BlcmF0aW9uID0gZ3RrX3ByaW50X29wZXJhdGlvbl9uZXcoKTsKKyAgICBHRXJy b3IqIGVycm9yID0gMDsKKworICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnRfZnVsbChmcmFtZSwg b3BlcmF0aW9uLCBHVEtfUFJJTlRfT1BFUkFUSU9OX0FDVElPTl9QUklOVF9ESUFMT0csICZlcnJv cik7CisgICAgZ19vYmplY3RfdW5yZWYob3BlcmF0aW9uKTsKIAogICAgIGlmIChlcnJvcikgewot ICAgICAgICBHdGtXaWRnZXQqIGRpYWxvZyA9IGd0a19tZXNzYWdlX2RpYWxvZ19uZXcoR1RLX1dJ TkRPVyh0b3BMZXZlbCksCisgICAgICAgIEd0a1dpZGdldCogd2luZG93ID0gZ3RrX3dpZGdldF9n ZXRfdG9wbGV2ZWwoR1RLX1dJREdFVChwcml2LT53ZWJWaWV3KSk7CisgICAgICAgIEd0a1dpZGdl dCogZGlhbG9nID0gZ3RrX21lc3NhZ2VfZGlhbG9nX25ldyhHVEtfV0lER0VUX1RPUExFVkVMKHdp bmRvdykgPyBHVEtfV0lORE9XKHdpbmRvdykgOiAwLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RLX0RJQUxPR19ERVNUUk9ZX1dJVEhfUEFSRU5U LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR1RL X01FU1NBR0VfRVJST1IsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBHVEtfQlVUVE9OU19DTE9TRSwKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYmZyYW1lLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5o CmluZGV4IDdlMjQ1NjUuLmY0NGY4MjUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYmZyYW1lLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaApA QCAtMjIsNiArMjIsOCBAQAogI2RlZmluZSBXRUJLSVRfV0VCX0ZSQU1FX0gKIAogI2luY2x1ZGUg PGdsaWItb2JqZWN0Lmg+CisjaW5jbHVkZSA8Z3RrL2d0ay5oPgorCiAjaW5jbHVkZSA8SmF2YVNj cmlwdENvcmUvSlNCYXNlLmg+CiAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0ZGVmaW5lcy5oPgpA QCAtMTA4LDYgKzExMCwxNSBAQCB3ZWJraXRfd2ViX2ZyYW1lX2ZpbmRfZnJhbWUgICAgICAgICAo V2ViS2l0V2ViRnJhbWUgICAgICAgKmZyYW1lLAogV0VCS0lUX0FQSSBKU0dsb2JhbENvbnRleHRS ZWYKIHdlYmtpdF93ZWJfZnJhbWVfZ2V0X2dsb2JhbF9jb250ZXh0IChXZWJLaXRXZWJGcmFtZSAg ICAgICAqZnJhbWUpOwogCitXRUJLSVRfQVBJIEd0a1ByaW50T3BlcmF0aW9uUmVzdWx0Cit3ZWJr aXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGwgICAgICAgICAoV2ViS2l0V2ViRnJhbWUgICAgICAgKmZy YW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEd0a1ByaW50T3BlcmF0 aW9uICAgICpvcGVyYXRpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg R3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gYWN0aW9uLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEdFcnJvciAgICAgICAgICAgICAgKiplcnJvcik7CisKK1dFQktJVF9BUEkg dm9pZAord2Via2l0X3dlYl9mcmFtZV9wcmludCAgICAgICAgICAgICAgKFdlYktpdFdlYkZyYW1l ICAgICAgICpmcmFtZSk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXR3ZWJ2aWV3LmNwcAppbmRleCA2MWMxY2I1Li5mMzZhNGU4IDEwMDY0NAotLS0gYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXR3ZWJ2aWV3LmNwcApAQCAtMTM4LDYgKzEzOCw3IEBAIGVudW0gewogICAgIENVVF9DTElQQk9B UkQsCiAgICAgRE9XTkxPQURfUkVRVUVTVEVELAogICAgIE1PVkVfQ1VSU09SLAorICAgIFBSSU5U X1JFUVVFU1RFRCwKICAgICBMQVNUX1NJR05BTAogfTsKIApAQCAtMTM3NCw2ICsxMzc1LDM0IEBA IHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KFdlYktpdFdlYlZpZXdDbGFz cyogd2ViVmlld0NsYXNzKQogICAgICAgICAgICAgR19UWVBFX05PTkUsIDEsCiAgICAgICAgICAg ICBHVEtfVFlQRV9NRU5VKTsKIAorICAgIC8qKgorICAgICAqIFdlYktpdFdlYlZpZXc6OnByaW50 LXJlcXVlc3RlZAorICAgICAqIEB3ZWJfdmlldzogdGhlIG9iamVjdCBpbiB3aGljaCB0aGUgc2ln bmFsIGlzIGVtaXR0ZWQKKyAgICAgKiBAd2ViX2ZyYW1lOiB0aGUgZnJhbWUgdGhhdCBpcyByZXF1 ZXN0aW5nIHRvIGJlIHByaW50ZWQKKyAgICAgKiBAcmV0dXJuOiAlVFJVRSBpZiB0aGUgcHJpbnQg cmVxdWVzdCBoYXMgYmVlbiBoYW5kbGVkLCAlRkFMU0UgaWYKKyAgICAgKiB0aGUgZGVmYXVsdCBo YW5kbGVyIHNob3VsZCBydW4KKyAgICAgKgorICAgICAqIEVtaXR0ZWQgd2hlbiBwcmludGluZyBp cyByZXF1ZXN0ZWQgYnkgdGhlIGZyYW1lLCB1c3VhbGx5CisgICAgICogYmVjYXVzZSBvZiBhIGph dmFzY3JpcHQgY2FsbC4gV2hpbGUgaGFuZGxpbmcgdGhpcyBzaWduYWwgeW91CisgICAgICogc2hv dWxkIGNhbGwgd2Via2l0X3dlYl9mcmFtZV9wcmludCgpIHRvIGRvIHRoZSBhY3R1YWwgcHJpbnRp bmcuCisgICAgICoKKyAgICAgKiBUaGUgZGVmYXVsdCBoYW5kbGVyIHdpbGwgcHJlc2VudCBhIHBy aW50IGRpYWxvZyBhbmQgY2FycnkgYQorICAgICAqIHByaW50IG9wZXJhdGlvbi4gTm90aWNlIHRo YXQgdGhpcyBtZWFucyB0aGF0IGlmIHlvdSBpbnRlbmQgdG8KKyAgICAgKiBpZ25vcmUgYSBwcmlu dCByZXF1ZXN0IHlvdSBtdXN0IGNvbm5lY3QgdG8gdGhpcyBzaWduYWwsIGFuZAorICAgICAqIHJl dHVybiAlVFJVRS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuNQorICAgICAqLworICAgIHdl YmtpdF93ZWJfdmlld19zaWduYWxzW1BSSU5UX1JFUVVFU1RFRF0gPSBnX3NpZ25hbF9uZXcoInBy aW50LXJlcXVlc3RlZCIsCisgICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyh3ZWJWaWV3Q2xh c3MpLAorICAgICAgICAgICAgKEdTaWduYWxGbGFncykoR19TSUdOQUxfUlVOX0xBU1QgfCBHX1NJ R05BTF9BQ1RJT04pLAorICAgICAgICAgICAgMCwKKyAgICAgICAgICAgIE5VTEwsCisgICAgICAg ICAgICBOVUxMLAorICAgICAgICAgICAgd2Via2l0X21hcnNoYWxfQk9PTEVBTl9fT0JKRUNULAor ICAgICAgICAgICAgR19UWVBFX0JPT0xFQU4sIDEsCisgICAgICAgICAgICBXRUJLSVRfVFlQRV9X RUJfRlJBTUUpOworCiAgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNbU1RBVFVTX0JBUl9URVhU X0NIQU5HRURdID0gZ19zaWduYWxfbmV3KCJzdGF0dXMtYmFyLXRleHQtY2hhbmdlZCIsCiAgICAg ICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyh3ZWJWaWV3Q2xhc3MpLAogICAgICAgICAgICAgKEdT aWduYWxGbGFncykoR19TSUdOQUxfUlVOX0xBU1QgfCBHX1NJR05BTF9BQ1RJT04pLAo= 29289 2009-04-06 14:39:14 -0700 2009-04-11 21:03:09 -0700 unit tests for printing 2009-04-06-Gustavo-Noronha-Silva-gustavo.noronha-collabora.co.uk-.patch text/plain 4853 gustavo YWUxNDNjODZhMjAyMTRhMTQ1Yzk0NDQ2MzNmMzA5ZjFjZjU3ODZiNApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAyZDM3NjhkLi5m YWM2OGE4IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDA5LTA0LTA2ICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMjg5OAorICAgICAgICBbR1RLXSBuZWVkIHByb3BlciBBUEkgZm9y IHByaW50aW5nCisKKyAgICAgICAgQWRkZWQgc2ltcGxlIHByaW50aW5nIHVuaXQgdGVzdHMuCisK KyAgICAgICAgKiB0ZXN0cy90ZXN0d2ViZnJhbWUuYzoKKyAgICAgICAgKHByaW50X3JlcXVlc3Rl ZF9jYik6CisgICAgICAgIChwcmludF90aW1lb3V0KToKKyAgICAgICAgKHRlc3Rfd2Via2l0X3dl Yl9mcmFtZV9wcmludGluZyk6CisgICAgICAgIChtYWluKToKKwogMjAwOS0wNC0wNiAgR3VzdGF2 byBOb3JvbmhhIFNpbHZhICA8Z25zQGdub21lLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdlYmZyYW1l LmMgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3R3ZWJmcmFtZS5jCmluZGV4IGUyZGEyOWMuLjU1NGQw ZDUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdlYmZyYW1lLmMKKysrIGIvV2Vi S2l0L2d0ay90ZXN0cy90ZXN0d2ViZnJhbWUuYwpAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiBDb3B5 cmlnaHQgKEMpIDIwMDggSG9sZ2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIKKyAqIENvcHlyaWdodCAo QykgMjAwOSBDb2xsYWJvcmEgTHRkLgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC0xNyw3ICsxOCwx MCBAQAogICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCiAgKi8KIAorI2luY2x1ZGUgPGVy cm5vLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CiAjaW5jbHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUg PGdsaWIvZ3N0ZGlvLmg+CiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgogI2luY2x1ZGUgPHdlYmtpdC93 ZWJraXQuaD4KIApAQCAtNjIsNiArNjYsODcgQEAgc3RhdGljIHZvaWQgdGVzdF93ZWJraXRfd2Vi X2ZyYW1lX2xpZmV0aW1lKHZvaWQpCiAgICAgZ19vYmplY3RfdW5yZWYod2ViRnJhbWUpOwogfQog CitzdGF0aWMgZ2Jvb2xlYW4gcHJpbnRfcmVxdWVzdGVkX2NiKFdlYktpdFdlYlZpZXcqIHdlYlZp ZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJGcmFtZSwgR01haW5Mb29wKiBsb29wKQoreworICAgIGdf b2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKHdlYlZpZXcpLCAic2lnbmFsLWhhbmRsZWQiLCBHSU5U X1RPX1BPSU5URVIoVFJVRSkpOworICAgIGdfbWFpbl9sb29wX3F1aXQobG9vcCk7CisgICAgcmV0 dXJuIFRSVUU7Cit9CisKK3N0YXRpYyB2b2lkIHByaW50X3RpbWVvdXQoR01haW5Mb29wKiBsb29w KQoreworICAgIGlmIChnX21haW5fbG9vcF9pc19ydW5uaW5nKGxvb3ApKQorICAgICAgICBnX21h aW5fbG9vcF9xdWl0KGxvb3ApOworfQorCitzdGF0aWMgdm9pZCB0ZXN0X3dlYmtpdF93ZWJfZnJh bWVfcHJpbnRpbmcodm9pZCkKK3sKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3OworCisgICAg d2ViVmlldyA9IFdFQktJVF9XRUJfVklFVyh3ZWJraXRfd2ViX3ZpZXdfbmV3KCkpOworICAgIGdf b2JqZWN0X3JlZl9zaW5rKHdlYlZpZXcpOworICAgIGdfYXNzZXJ0X2NtcGludChHX09CSkVDVCh3 ZWJWaWV3KS0+cmVmX2NvdW50LCA9PSwgMSk7CisKKyAgICB3ZWJraXRfd2ViX3ZpZXdfbG9hZF9z dHJpbmcod2ViVmlldywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIjxodG1sPjxi b2R5PjxoMT5XZWJLaXRHVEsrITwvaDE+PC9ib2R5PjwvaHRtbD4iLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAidGV4dC9odG1sIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgInV0Zi04IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImZpbGU6Ly8i KTsKKworICAgIEdNYWluTG9vcCogbG9vcCA9IGdfbWFpbl9sb29wX25ldyhOVUxMLCBUUlVFKTsK KworICAgIC8vIERvZXMgamF2YXNjcmlwdCBwcmludCgpIHdvcmsgY29ycmVjdGx5PworICAgIGdf c2lnbmFsX2Nvbm5lY3Qod2ViVmlldywgInByaW50LXJlcXVlc3RlZCIsCisgICAgICAgICAgICAg ICAgICAgICBHX0NBTExCQUNLKHByaW50X3JlcXVlc3RlZF9jYiksCisgICAgICAgICAgICAgICAg ICAgICBsb29wKTsKKworICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKHdlYlZpZXcpLCAi c2lnbmFsLWhhbmRsZWQiLCBHSU5UX1RPX1BPSU5URVIoRkFMU0UpKTsKKyAgICB3ZWJraXRfd2Vi X3ZpZXdfZXhlY3V0ZV9zY3JpcHQgKHdlYlZpZXcsICJwcmludCgpOyIpOworCisgICAgLy8gR2l2 ZSBqYXZhc2NyaXB0Y29yZSBzb21lIHRpbWUgdG8gcHJvY2VzcyB0aGUgcHJpbnQgcmVxdWVzdCwg YnV0CisgICAgLy8gcHJlcGFyZSBhIHRpbWVvdXQgdG8gYXZvaWQgaXQgcnVubmluZyBmb3JldmVy IGluIGNhc2UgdGhlIHNpZ25hbCBpcworICAgIC8vIG5ldmVyIGVtaXR0ZWQuCisgICAgZ190aW1l b3V0X2FkZCgxMDAwLCAoR1NvdXJjZUZ1bmMpcHJpbnRfdGltZW91dCwgbG9vcCk7CisgICAgZ19t YWluX2xvb3BfcnVuKGxvb3ApOworCisgICAgZ19hc3NlcnRfY21waW50KEdQT0lOVEVSX1RPX0lO VChnX29iamVjdF9nZXRfZGF0YShHX09CSkVDVCh3ZWJWaWV3KSwgInNpZ25hbC1oYW5kbGVkIikp LCA9PSwgVFJVRSk7CisKKyAgICAvLyBEb2VzIHByaW50aW5nIGRpcmVjdGx5IHRvIGEgZmlsZT8K KyAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKKyAgICBnY2hhciogdGVtcG9yYXJ5RmlsZW5hbWUg PSBOVUxMOworICAgIGdpbnQgZmQgPSBnX2ZpbGVfb3Blbl90bXAgKCJ3ZWJraXQtdGVzdHdlYmZy YW1lLVhYWFhYWCIsICZ0ZW1wb3JhcnlGaWxlbmFtZSwgJmVycm9yKTsKKyAgICBjbG9zZShmZCk7 CisKKyAgICBpZiAoZXJyb3IpIHsKKyAgICAgICAgZ19jcml0aWNhbCgiRmFpbGVkIHRvIG9wZW4g YSB0ZW1wb3JhcnkgZmlsZSBmb3Igd3JpdGluZzogJXMuIiwgZXJyb3ItPm1lc3NhZ2UpOworICAg ICAgICBnX2Vycm9yX2ZyZWUoZXJyb3IpOworICAgICAgICBnb3RvIGNsZWFudXA7CisgICAgfQor CisgICAgLy8gV2UgZGVsZXRlIHRoZSBmaWxlLCBzbyB0aGF0IHdlIGNhbiBlYXNpbHkgZmlndXJl IG91dCB0aGF0IHRoZQorICAgIC8vIGZpbGUgZ290IHByaW50ZWQ7CisgICAgaWYgKGdfdW5saW5r KHRlbXBvcmFyeUZpbGVuYW1lKSA9PSAtMSkgeworICAgICAgICBnX3dhcm5pbmcoIkZhaWxlZCB0 byBkZWxldGUgdGhlIHRlbXBvcmFyeSBmaWxlOiAlcy5cblRoaXMgbWF5IGNhdXNlIHRoZSB0ZXN0 IHRvIGJlIGJvZ3VzLiIsIGdfc3RyZXJyb3IoZXJybm8pKTsKKyAgICB9CisKKyAgICBXZWJLaXRX ZWJGcmFtZSogd2ViRnJhbWUgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X21haW5fZnJhbWUod2ViVmll dyk7CisgICAgR3RrUHJpbnRPcGVyYXRpb24qIG9wZXJhdGlvbiA9IGd0a19wcmludF9vcGVyYXRp b25fbmV3KCk7CisgICAgR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24gYWN0aW9uID0gR1RLX1BSSU5U X09QRVJBVElPTl9BQ1RJT05fRVhQT1JUOworICAgIEd0a1ByaW50T3BlcmF0aW9uUmVzdWx0IHJl c3VsdDsKKworICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X2V4cG9ydF9maWxlbmFtZShvcGVy YXRpb24sIHRlbXBvcmFyeUZpbGVuYW1lKTsKKyAgICByZXN1bHQgPSB3ZWJraXRfd2ViX2ZyYW1l X3ByaW50X2Z1bGwgKHdlYkZyYW1lLCBvcGVyYXRpb24sIGFjdGlvbiwgTlVMTCk7CisKKyAgICBn X2Fzc2VydF9jbXBpbnQocmVzdWx0LCA9PSwgR1RLX1BSSU5UX09QRVJBVElPTl9SRVNVTFRfQVBQ TFkpOworICAgIGdfYXNzZXJ0X2NtcGludChnX2ZpbGVfdGVzdCh0ZW1wb3JhcnlGaWxlbmFtZSwg R19GSUxFX1RFU1RfSVNfUkVHVUxBUiksID09LCBUUlVFKTsKKworICAgIGdfdW5saW5rKHRlbXBv cmFyeUZpbGVuYW1lKTsKKyAgICBnX29iamVjdF91bnJlZihvcGVyYXRpb24pOworY2xlYW51cDoK KyAgICBnX29iamVjdF91bnJlZih3ZWJWaWV3KTsKKyAgICBnX2ZyZWUodGVtcG9yYXJ5RmlsZW5h bWUpOworfQorCiBpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCiB7CiAgICAgZ190aHJl YWRfaW5pdChOVUxMKTsKQEAgLTcwLDYgKzE1NSw3IEBAIGludCBtYWluKGludCBhcmdjLCBjaGFy KiogYXJndikKICAgICBnX3Rlc3RfYnVnX2Jhc2UoImh0dHBzOi8vYnVncy53ZWJraXQub3JnLyIp OwogICAgIGdfdGVzdF9hZGRfZnVuYygiL3dlYmtpdC93ZWJ2aWV3L2NyZWF0ZV9kZXN0cm95Iiwg dGVzdF93ZWJraXRfd2ViX2ZyYW1lX2NyZWF0ZV9kZXN0cm95KTsKICAgICBnX3Rlc3RfYWRkX2Z1 bmMoIi93ZWJraXQvd2ViZnJhbWUvbGlmZXRpbWUiLCB0ZXN0X3dlYmtpdF93ZWJfZnJhbWVfbGlm ZXRpbWUpOworICAgIGdfdGVzdF9hZGRfZnVuYygiL3dlYmtpdC93ZWJ2aWV3L3ByaW50aW5nIiwg dGVzdF93ZWJraXRfd2ViX2ZyYW1lX3ByaW50aW5nKTsKICAgICByZXR1cm4gZ190ZXN0X3J1biAo KTsKIH0KIAo= 29424 2009-04-12 16:04:03 -0700 2009-04-12 22:16:22 -0700 printing API printing.patch text/plain 11048 gustavo RnJvbSBhYTk1ZDEzYTMyMGU2ZDYwMmI5MDFjZWNjODY5MjgxOWUxNzg4ZTVmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGtvdkBrb3YuZXRpLmJy PgpEYXRlOiBNb24sIDIzIE1hciAyMDA5IDE2OjEyOjQ2IC0wMzAwClN1YmplY3Q6IFtQQVRDSCAx LzJdIDIwMDktMDQtMTIgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+Cgog ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4OTgKICAgICAgICBbR1RLXSBuZWVkIHByb3Bl ciBBUEkgZm9yIHByaW50aW5nCgogICAgICAgIEltcGxlbWVudCBwcm9wZXIgcHJpbnRpbmcgQVBJ LCB1c2luZyB0aGUgR1RLKyBwcmludGluZyBBUEkuCgogICAgICAgICogV2ViQ29yZVN1cHBvcnQv Q2hyb21lQ2xpZW50R3RrLmNwcDoKICAgICAgICAoV2ViS2l0OjpDaHJvbWVDbGllbnQ6OnByaW50 KToKICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CiAgICAgICAgKiB3ZWJraXQvd2Vi a2l0d2ViZnJhbWUuY3BwOgogICAgICAgICogd2Via2l0L3dlYmtpdHdlYmZyYW1lLmg6CiAgICAg ICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6Ci0tLQogV2ViS2l0L2d0ay9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxNiArKysrKysKIFdlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNwcCB8ICAgIDkgKysrLQogV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgIHwgICAgMyAtCiBXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJmcmFtZS5jcHAgICAgICAgICAgfCAgIDY1ICsrKysrKysrKysrKysrKysrKysr LS0tLS0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmggICAgICAgICAgICB8ICAg MTEgKysrKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgICAgICAgICAgIHwg ICAzMCArKysrKysrKysrKwogNiBmaWxlcyBjaGFuZ2VkLCAxMTcgaW5zZXJ0aW9ucygrKSwgMTcg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQv Z3RrL0NoYW5nZUxvZwppbmRleCBmNDcxNDg5Li45MWY1OTE3IDEwMDY0NAotLS0gYS9XZWJLaXQv Z3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBA CisyMDA5LTA0LTEyICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxnbnNAZ25vbWUub3JnPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjg5OAorICAgICAgICBbR1RLXSBuZWVkIHBy b3BlciBBUEkgZm9yIHByaW50aW5nCisKKyAgICAgICAgSW1wbGVtZW50IHByb3BlciBwcmludGlu ZyBBUEksIHVzaW5nIHRoZSBHVEsrIHByaW50aW5nIEFQSS4KKworICAgICAgICAqIFdlYkNvcmVT dXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkNocm9tZUNsaWVu dDo6cHJpbnQpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRwcml2YXRlLmg6CisgICAgICAgICog d2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2ViZnJh bWUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisKIDIwMDktMDQtMTAg IEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9X ZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuY3BwCmluZGV4IGJiODA5MWEuLjVlM2ZlYWQg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmNw cAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5jcHAKQEAg LTQwNCw3ICs0MDQsMTQgQEAgdm9pZCBDaHJvbWVDbGllbnQ6OnNldFRvb2xUaXAoY29uc3QgU3Ry aW5nJiB0b29sVGlwKQogCiB2b2lkIENocm9tZUNsaWVudDo6cHJpbnQoRnJhbWUqIGZyYW1lKQog ewotICAgIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoa2l0KGZyYW1lKSk7CisgICAgV2ViS2l0V2Vi RnJhbWUqIHdlYkZyYW1lID0ga2l0KGZyYW1lKTsKKyAgICBnYm9vbGVhbiBpc0hhbmRsZWQgPSBm YWxzZTsKKyAgICBnX3NpZ25hbF9lbWl0X2J5X25hbWUobV93ZWJWaWV3LCAicHJpbnQtcmVxdWVz dGVkIiwgd2ViRnJhbWUsICZpc0hhbmRsZWQpOworCisgICAgaWYgKGlzSGFuZGxlZCkKKyAgICAg ICAgcmV0dXJuOworCisgICAgd2Via2l0X3dlYl9mcmFtZV9wcmludCh3ZWJGcmFtZSk7CiB9CiAK IHZvaWQgQ2hyb21lQ2xpZW50OjpleGNlZWRlZERhdGFiYXNlUXVvdGEoRnJhbWUqIGZyYW1lLCBj b25zdCBTdHJpbmcmKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0 ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCmluZGV4IDBiODNhMTEuLjgy MzBiODYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaAorKysg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAgLTE3Niw5ICsxNzYsNiBAQCBl eHRlcm4gIkMiIHsKICAgICBXRUJLSVRfQVBJIGdjaGFyKgogICAgIHdlYmtpdF93ZWJfZnJhbWVf Z2V0X2lubmVyX3RleHQgKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiAKLSAgICBXRUJLSVRfQVBJ IHZvaWQKLSAgICB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50IChXZWJLaXRXZWJGcmFtZSogZnJhbWUp OwotCiAgICAgV0VCS0lUX0FQSSBnY2hhcioKICAgICB3ZWJraXRfd2ViX2ZyYW1lX2R1bXBfcmVu ZGVyX3RyZWUgKFdlYktpdFdlYkZyYW1lKiBmcmFtZSk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl YmZyYW1lLmNwcAppbmRleCBkM2NhMzFkLi43YmEyMmY3IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2ViZnJhbWUuY3BwCkBAIC02LDYgKzYsNyBAQAogICogQ29weXJpZ2h0IChDKSAyMDA4IENvbGxh Ym9yYSBMdGQuCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggTnVhbnRpIEx0ZC4KICAqIENvcHlyaWdo dCAoQykgMjAwOSBKYW4gQWxvbnpvIDxqbWFsb256b0BnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQg KEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhIDxnbnNAZ25vbWUub3JnPgogICoKICAqIFRo aXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IKICAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVy YWwgUHVibGljCkBAIC02MTEsNyArNjEyLDcgQEAgZ2NoYXIqIHdlYmtpdF93ZWJfZnJhbWVfZHVt cF9yZW5kZXJfdHJlZShXZWJLaXRXZWJGcmFtZSogZnJhbWUpCiAgICAgcmV0dXJuIGdfc3RyZHVw KHN0cmluZy51dGY4KCkuZGF0YSgpKTsKIH0KIAotc3RhdGljIHZvaWQgYmVnaW5fcHJpbnQoR3Rr UHJpbnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdwb2ludGVyIHVz ZXJfZGF0YSkKK3N0YXRpYyB2b2lkIGJlZ2luX3ByaW50X2NhbGxiYWNrKEd0a1ByaW50T3BlcmF0 aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRlciB1c2VyX2RhdGEpCiB7 CiAgICAgUHJpbnRDb250ZXh0KiBwcmludENvbnRleHQgPSByZWludGVycHJldF9jYXN0PFByaW50 Q29udGV4dCo+KHVzZXJfZGF0YSk7CiAKQEAgLTYyOSw3ICs2MzAsNyBAQCBzdGF0aWMgdm9pZCBi ZWdpbl9wcmludChHdGtQcmludE9wZXJhdGlvbiogb3AsIEd0a1ByaW50Q29udGV4dCogY29udGV4 dCwgZ3BvaW50ZQogICAgIGd0a19wcmludF9vcGVyYXRpb25fc2V0X25fcGFnZXMob3AsIHByaW50 Q29udGV4dC0+cGFnZUNvdW50KCkpOwogfQogCi1zdGF0aWMgdm9pZCBkcmF3X3BhZ2UoR3RrUHJp bnRPcGVyYXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdpbnQgcGFnZV9uciwg Z3BvaW50ZXIgdXNlcl9kYXRhKQorc3RhdGljIHZvaWQgZHJhd19wYWdlX2NhbGxiYWNrKEd0a1By aW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2VfbnIs IGdwb2ludGVyIHVzZXJfZGF0YSkKIHsKICAgICBQcmludENvbnRleHQqIHByaW50Q29udGV4dCA9 IHJlaW50ZXJwcmV0X2Nhc3Q8UHJpbnRDb250ZXh0Kj4odXNlcl9kYXRhKTsKIApAQCAtNjM5LDM0 ICs2NDAsNzIgQEAgc3RhdGljIHZvaWQgZHJhd19wYWdlKEd0a1ByaW50T3BlcmF0aW9uKiBvcCwg R3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBnaW50IHBhZ2UKICAgICBwcmludENvbnRleHQtPnNw b29sUGFnZShjdHgsIHBhZ2VfbnIsIHdpZHRoKTsKIH0KIAotc3RhdGljIHZvaWQgZW5kX3ByaW50 KEd0a1ByaW50T3BlcmF0aW9uKiBvcCwgR3RrUHJpbnRDb250ZXh0KiBjb250ZXh0LCBncG9pbnRl ciB1c2VyX2RhdGEpCitzdGF0aWMgdm9pZCBlbmRfcHJpbnRfY2FsbGJhY2soR3RrUHJpbnRPcGVy YXRpb24qIG9wLCBHdGtQcmludENvbnRleHQqIGNvbnRleHQsIGdwb2ludGVyIHVzZXJfZGF0YSkK IHsKICAgICBQcmludENvbnRleHQqIHByaW50Q29udGV4dCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UHJp bnRDb250ZXh0Kj4odXNlcl9kYXRhKTsKICAgICBwcmludENvbnRleHQtPmVuZCgpOwogfQogCi12 b2lkIHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQorLyoqCisg KiB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGw6CisgKiBAZnJhbWU6IGEgI1dlYktpdFdlYkZy YW1lIHRvIGJlIHByaW50ZWQKKyAqIEBvcGVyYXRpb246IHRoZSAjR3RrUHJpbnRPcGVyYXRpb24g dG8gYmUgY2FycmllZAorICogQGFjdGlvbjogdGhlICNHdGtQcmludE9wZXJhdGlvbkFjdGlvbiB0 byBiZSBwZXJmb3JtZWQKKyAqIEBlcnJvcjogI0dFcnJvciBmb3IgZXJyb3IgcmV0dXJuCisgKgor ICogUHJpbnRzIHRoZSBnaXZlbiAjV2ViS2l0RnJhbWUsIHVzaW5nIHRoZSBnaXZlbiAjR3RrUHJp bnRPcGVyYXRpb24KKyAqIGFuZCAjR3RrUHJpbnRPcGVyYXRpb25BY3Rpb24uIFRoaXMgZnVuY3Rp b24gd3JhcHMgYSBjYWxsIHRvCisgKiBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bigpIGZvciBwcmlu dGluZyB0aGUgY29udGVudHMgb2YgdGhlCisgKiAjV2ViS2l0V2ViRnJhbWUuCisgKgorICogU2lu Y2U6IDEuMS41CisgKi8KK0d0a1ByaW50T3BlcmF0aW9uUmVzdWx0IHdlYmtpdF93ZWJfZnJhbWVf cHJpbnRfZnVsbChXZWJLaXRXZWJGcmFtZSogZnJhbWUsIEd0a1ByaW50T3BlcmF0aW9uKiBvcGVy YXRpb24sIEd0a1ByaW50T3BlcmF0aW9uQWN0aW9uIGFjdGlvbiwgR0Vycm9yKiogZXJyb3IpCiB7 CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9GUkFNRShmcmFtZSksIEdU S19QUklOVF9PUEVSQVRJT05fUkVTVUxUX0VSUk9SKTsKKyAgICBnX3JldHVybl92YWxfaWZfZmFp bChHVEtfSVNfUFJJTlRfT1BFUkFUSU9OKG9wZXJhdGlvbiksIEdUS19QUklOVF9PUEVSQVRJT05f UkVTVUxUX0VSUk9SKTsKKwogICAgIEd0a1dpZGdldCogdG9wTGV2ZWwgPSBndGtfd2lkZ2V0X2dl dF90b3BsZXZlbChHVEtfV0lER0VUKHdlYmtpdF93ZWJfZnJhbWVfZ2V0X3dlYl92aWV3KGZyYW1l KSkpOwogICAgIGlmICghR1RLX1dJREdFVF9UT1BMRVZFTCh0b3BMZXZlbCkpCiAgICAgICAgIHRv cExldmVsID0gTlVMTDsKIAogICAgIEZyYW1lKiBjb3JlRnJhbWUgPSBjb3JlKGZyYW1lKTsKICAg ICBpZiAoIWNvcmVGcmFtZSkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1cm4gR1RLX1BS SU5UX09QRVJBVElPTl9SRVNVTFRfRVJST1I7CiAKICAgICBQcmludENvbnRleHQgcHJpbnRDb250 ZXh0KGNvcmVGcmFtZSk7CiAKLSAgICBHdGtQcmludE9wZXJhdGlvbiogb3AgPSBndGtfcHJpbnRf b3BlcmF0aW9uX25ldygpOwotICAgIGdfc2lnbmFsX2Nvbm5lY3Qob3AsICJiZWdpbi1wcmludCIs IEdfQ0FMTEJBQ0soYmVnaW5fcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsKLSAgICBnX3NpZ25hbF9j b25uZWN0KG9wLCAiZHJhdy1wYWdlIiwgR19DQUxMQkFDSyhkcmF3X3BhZ2UpLCAmcHJpbnRDb250 ZXh0KTsKLSAgICBnX3NpZ25hbF9jb25uZWN0KG9wLCAiZW5kLXByaW50IiwgR19DQUxMQkFDSyhl bmRfcHJpbnQpLCAmcHJpbnRDb250ZXh0KTsKLSAgICBHRXJyb3IgKmVycm9yID0gTlVMTDsKLSAg ICBndGtfcHJpbnRfb3BlcmF0aW9uX3J1bihvcCwgR1RLX1BSSU5UX09QRVJBVElPTl9BQ1RJT05f UFJJTlRfRElBTE9HLCBHVEtfV0lORE9XKHRvcExldmVsKSwgJmVycm9yKTsKLSAgICBnX29iamVj dF91bnJlZihvcCk7CisgICAgZ19zaWduYWxfY29ubmVjdChvcGVyYXRpb24sICJiZWdpbi1wcmlu dCIsIEdfQ0FMTEJBQ0soYmVnaW5fcHJpbnRfY2FsbGJhY2spLCAmcHJpbnRDb250ZXh0KTsKKyAg ICBnX3NpZ25hbF9jb25uZWN0KG9wZXJhdGlvbiwgImRyYXctcGFnZSIsIEdfQ0FMTEJBQ0soZHJh d19wYWdlX2NhbGxiYWNrKSwgJnByaW50Q29udGV4dCk7CisgICAgZ19zaWduYWxfY29ubmVjdChv cGVyYXRpb24sICJlbmQtcHJpbnQiLCBHX0NBTExCQUNLKGVuZF9wcmludF9jYWxsYmFjayksICZw cmludENvbnRleHQpOworCisgICAgcmV0dXJuIGd0a19wcmludF9vcGVyYXRpb25fcnVuKG9wZXJh dGlvbiwgYWN0aW9uLCBHVEtfV0lORE9XKHRvcExldmVsKSwgZXJyb3IpOworfQorCisvKioKKyAq IHdlYmtpdF93ZWJfZnJhbWVfcHJpbnQ6CisgKiBAZnJhbWU6IGEgI1dlYktpdFdlYkZyYW1lCisg KgorICogUHJpbnRzIHRoZSBnaXZlbiAjV2ViS2l0RnJhbWUsIGJ5IHByZXNlbnRpbmcgYSBwcmlu dCBkaWFsb2cgdG8gdGhlCisgKiB1c2VyLiBJZiB5b3UgbmVlZCBtb3JlIGNvbnRyb2wgb3ZlciB0 aGUgcHJpbnRpbmcgcHJvY2Vzcywgc2VlCisgKiB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50X2Z1bGwo KS4KKyAqCisgKiBTaW5jZTogMS4xLjUKKyAqLwordm9pZCB3ZWJraXRfd2ViX2ZyYW1lX3ByaW50 KFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKK3sKKyAgICBnX3JldHVybl9pZl9mYWlsKFdFQktJVF9J U19XRUJfRlJBTUUoZnJhbWUpKTsKKworICAgIFdlYktpdFdlYkZyYW1lUHJpdmF0ZSogcHJpdiA9 IGZyYW1lLT5wcml2OworICAgIEd0a1ByaW50T3BlcmF0aW9uKiBvcGVyYXRpb24gPSBndGtfcHJp bnRfb3BlcmF0aW9uX25ldygpOworICAgIEdFcnJvciogZXJyb3IgPSAwOworCisgICAgd2Via2l0 X3dlYl9mcmFtZV9wcmludF9mdWxsKGZyYW1lLCBvcGVyYXRpb24sIEdUS19QUklOVF9PUEVSQVRJ T05fQUNUSU9OX1BSSU5UX0RJQUxPRywgJmVycm9yKTsKKyAgICBnX29iamVjdF91bnJlZihvcGVy YXRpb24pOwogCiAgICAgaWYgKGVycm9yKSB7Ci0gICAgICAgIEd0a1dpZGdldCogZGlhbG9nID0g Z3RrX21lc3NhZ2VfZGlhbG9nX25ldyhHVEtfV0lORE9XKHRvcExldmVsKSwKKyAgICAgICAgR3Rr V2lkZ2V0KiB3aW5kb3cgPSBndGtfd2lkZ2V0X2dldF90b3BsZXZlbChHVEtfV0lER0VUKHByaXYt PndlYlZpZXcpKTsKKyAgICAgICAgR3RrV2lkZ2V0KiBkaWFsb2cgPSBndGtfbWVzc2FnZV9kaWFs b2dfbmV3KEdUS19XSURHRVRfVE9QTEVWRUwod2luZG93KSA/IEdUS19XSU5ET1cod2luZG93KSA6 IDAsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBH VEtfRElBTE9HX0RFU1RST1lfV0lUSF9QQVJFTlQsCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBHVEtfTUVTU0FHRV9FUlJPUiwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdUS19CVVRUT05TX0NMT1NF LApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaCBiL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYmZyYW1lLmgKaW5kZXggN2UyNDU2NS4uZjQ0ZjgyNSAxMDA2 NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZnJhbWUuaAorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXR3ZWJmcmFtZS5oCkBAIC0yMiw2ICsyMiw4IEBACiAjZGVmaW5lIFdF QktJVF9XRUJfRlJBTUVfSAogCiAjaW5jbHVkZSA8Z2xpYi1vYmplY3QuaD4KKyNpbmNsdWRlIDxn dGsvZ3RrLmg+CisKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU0Jhc2UuaD4KIAogI2luY2x1 ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CkBAIC0xMDgsNiArMTEwLDE1IEBAIHdlYmtpdF93 ZWJfZnJhbWVfZmluZF9mcmFtZSAgICAgICAgIChXZWJLaXRXZWJGcmFtZSAgICAgICAqZnJhbWUs CiBXRUJLSVRfQVBJIEpTR2xvYmFsQ29udGV4dFJlZgogd2Via2l0X3dlYl9mcmFtZV9nZXRfZ2xv YmFsX2NvbnRleHQgKFdlYktpdFdlYkZyYW1lICAgICAgICpmcmFtZSk7CiAKK1dFQktJVF9BUEkg R3RrUHJpbnRPcGVyYXRpb25SZXN1bHQKK3dlYmtpdF93ZWJfZnJhbWVfcHJpbnRfZnVsbCAgICAg ICAgIChXZWJLaXRXZWJGcmFtZSAgICAgICAqZnJhbWUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgR3RrUHJpbnRPcGVyYXRpb24gICAgKm9wZXJhdGlvbiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHdGtQcmludE9wZXJhdGlvbkFjdGlvbiBhY3Rp b24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0Vycm9yICAgICAgICAg ICAgICAqKmVycm9yKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfd2ViX2ZyYW1lX3ByaW50 ICAgICAgICAgICAgICAoV2ViS2l0V2ViRnJhbWUgICAgICAgKmZyYW1lKTsKKwogR19FTkRfREVD TFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IDNlODlmNzku LjE1MjRlYmIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw CisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0xMzksNiArMTM5 LDcgQEAgZW51bSB7CiAgICAgQ1VUX0NMSVBCT0FSRCwKICAgICBET1dOTE9BRF9SRVFVRVNURUQs CiAgICAgTU9WRV9DVVJTT1IsCisgICAgUFJJTlRfUkVRVUVTVEVELAogICAgIExBU1RfU0lHTkFM CiB9OwogCkBAIC0xMzc1LDYgKzEzNzYsMzUgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3 X2NsYXNzX2luaXQoV2ViS2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAg ICBHX1RZUEVfTk9ORSwgMSwKICAgICAgICAgICAgIEdUS19UWVBFX01FTlUpOwogCisgICAgLyoq CisgICAgICogV2ViS2l0V2ViVmlldzo6cHJpbnQtcmVxdWVzdGVkCisgICAgICogQHdlYl92aWV3 OiB0aGUgb2JqZWN0IGluIHdoaWNoIHRoZSBzaWduYWwgaXMgZW1pdHRlZAorICAgICAqIEB3ZWJf ZnJhbWU6IHRoZSBmcmFtZSB0aGF0IGlzIHJlcXVlc3RpbmcgdG8gYmUgcHJpbnRlZAorICAgICAq IEByZXR1cm46ICVUUlVFIGlmIHRoZSBwcmludCByZXF1ZXN0IGhhcyBiZWVuIGhhbmRsZWQsICVG QUxTRSBpZgorICAgICAqIHRoZSBkZWZhdWx0IGhhbmRsZXIgc2hvdWxkIHJ1bgorICAgICAqCisg ICAgICogRW1pdHRlZCB3aGVuIHByaW50aW5nIGlzIHJlcXVlc3RlZCBieSB0aGUgZnJhbWUsIHVz dWFsbHkKKyAgICAgKiBiZWNhdXNlIG9mIGEgamF2YXNjcmlwdCBjYWxsLiBXaGVuIGhhbmRsaW5n IHRoaXMgc2lnbmFsIHlvdQorICAgICAqIHNob3VsZCBjYWxsIHdlYmtpdF93ZWJfZnJhbWVfcHJp bnRfZnVsbCgpIG9yCisgICAgICogd2Via2l0X3dlYl9mcmFtZV9wcmludCgpIHRvIGRvIHRoZSBh Y3R1YWwgcHJpbnRpbmcuCisgICAgICoKKyAgICAgKiBUaGUgZGVmYXVsdCBoYW5kbGVyIHdpbGwg cHJlc2VudCBhIHByaW50IGRpYWxvZyBhbmQgY2FycnkgYQorICAgICAqIHByaW50IG9wZXJhdGlv bi4gTm90aWNlIHRoYXQgdGhpcyBtZWFucyB0aGF0IGlmIHlvdSBpbnRlbmQgdG8KKyAgICAgKiBp Z25vcmUgYSBwcmludCByZXF1ZXN0IHlvdSBtdXN0IGNvbm5lY3QgdG8gdGhpcyBzaWduYWwsIGFu ZAorICAgICAqIHJldHVybiAlVFJVRS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuNQorICAg ICAqLworICAgIHdlYmtpdF93ZWJfdmlld19zaWduYWxzW1BSSU5UX1JFUVVFU1RFRF0gPSBnX3Np Z25hbF9uZXcoInByaW50LXJlcXVlc3RlZCIsCisgICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFT Uyh3ZWJWaWV3Q2xhc3MpLAorICAgICAgICAgICAgKEdTaWduYWxGbGFncykoR19TSUdOQUxfUlVO X0xBU1QgfCBHX1NJR05BTF9BQ1RJT04pLAorICAgICAgICAgICAgMCwKKyAgICAgICAgICAgIGdf c2lnbmFsX2FjY3VtdWxhdG9yX3RydWVfaGFuZGxlZCwKKyAgICAgICAgICAgIE5VTEwsCisgICAg ICAgICAgICB3ZWJraXRfbWFyc2hhbF9CT09MRUFOX19PQkpFQ1QsCisgICAgICAgICAgICBHX1RZ UEVfQk9PTEVBTiwgMSwKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX1dFQl9GUkFNRSk7CisKICAg ICB3ZWJraXRfd2ViX3ZpZXdfc2lnbmFsc1tTVEFUVVNfQkFSX1RFWFRfQ0hBTkdFRF0gPSBnX3Np Z25hbF9uZXcoInN0YXR1cy1iYXItdGV4dC1jaGFuZ2VkIiwKICAgICAgICAgICAgIEdfVFlQRV9G Uk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCiAgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShHX1NJ R05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCi0tIAoxLjYuMi4yCgo=