Attachment #119396 for bug #74591

View Details Raw Unified Return to Bug 74591

| Differences between



2011-12-14  Keishi Hattori  <keishi@webkit.org>

        Refactor input type color WebCore part
        https://bugs.webkit.org/show_bug.cgi?id=74591

        Reviewed by Kent Tamura.

        Changing ColorChooser to address issues raised in Bug 65897.
        Chrome::createColorChooser will return a WebCore::ColorChooser instance
        so the WebCore side (ColorInputType) and call the WebKit side. We pass the ColorChooserClient as an argument
        to Chrome::createColorChooser so the WebKit side can call callbacks, didEndChooser and didChooseColor.

        * html/ColorInputType.cpp:
        (WebCore::ColorInputType::~ColorInputType):
        (WebCore::ColorInputType::setValue):
        (WebCore::ColorInputType::handleDOMActivateEvent): Calls createColorChooser to open the color chooser.
        (WebCore::ColorInputType::detach):
        (WebCore::ColorInputType::didEndChooser): Release the ColorChooser object.
        (WebCore::ColorInputType::endColorChooser):
        (WebCore::ColorInputType::updateColorSwatch): Added argument so it will compile again.
        * html/ColorInputType.h:
        * html/HTMLInputElement.cpp:
        (WebCore::HTMLInputElement::selectColorInColorChooser):
        * loader/EmptyClients.h:
        (WebCore::EmptyChromeClient::createColorChooser):
        * loader/FrameLoader.cpp:
        * page/Chrome.cpp:
        (WebCore::Chrome::createColorChooser): Opens the color chooser. Returns a ColorChooser PassOwnPtr.
        * page/Chrome.h:
        * page/ChromeClient.h:
        * platform/ColorChooser.h:
        (WebCore::ColorChooser::~ColorChooser):
        (WebCore::ColorChooser::setSelectedColor):
        (WebCore::ColorChooser::endChooser):
        * platform/ColorChooserClient.h: Added.

2011-12-14  Kenneth Russell  <kbr@google.com>

        Unreviewed, rolling out r102816.



#include "config.h"
#include "ColorInputType.h"

#include "CSSPropertyNames.h"
#include "Chrome.h"
#include "Color.h"
#include "HTMLDivElement.h"

#include "MouseEvent.h"
#include "ScriptController.h"
#include "ShadowRoot.h"

#include <wtf/PassOwnPtr.h>
#include <wtf/text/WTFString.h>



ColorInputType::~ColorInputType()
{
    endColorChooser();
}

bool ColorInputType::isColorControl() const

        return;

    updateColorSwatch();
    if (m_chooser)
        m_chooser->setSelectedColor(valueAsColor());
        chrome->setSelectedColorInColorChooser(chooser(), valueAsColor());
}

void ColorInputType::handleDOMActivateEvent(Event* event)

    if (!ScriptController::processingUserGesture())
        return;

    Chrome* chrome = this->chrome();
    if (chrome && !m_chooser)
        m_chooser = chrome->createColorChooser(this, valueAsColor());

    event->setDefaultHandled();
}

void ColorInputType::detach()
{
    endColorChooser();
}

void ColorInputType::didChooseColor(const Color& color)

    element()->dispatchFormControlChangeEvent();
}

void ColorInputType::didEndChooser()
{
    m_chooser.clear();
}

void ColorInputType::endColorChooser()
{
    if (m_chooser)
        m_chooser->endChooser();
        chrome->cleanupColorChooser(chooser());
    discardChooser();
}

void ColorInputType::updateColorSwatch()

    if (!colorSwatch)
        return;

    colorSwatch->style()->setProperty(CSSPropertyBackgroundColor, element()->value(), false, ASSERT_NO_EXCEPTION);
    colorSwatch->style()->setProperty("background-color", element()->value(), ec);
}

HTMLElement* ColorInputType::shadowColorSwatch() const



#ifndef ColorInputType_h
#define ColorInputType_h

#include "ColorChooserClient.h"
#include "InputType.h"

#if ENABLE(INPUT_COLOR)

    static PassOwnPtr<InputType> create(HTMLInputElement*);
    virtual ~ColorInputType();

    // ColorChooserClient implementation.
    virtual void didChooseColor(const Color&) OVERRIDE;
    virtual void didEndChooser() OVERRIDE;

private:
    ColorInputType(HTMLInputElement* element) : InputType(element) { }
    virtual bool isColorControl() const;

    virtual void handleDOMActivateEvent(Event*);
    virtual void detach();

    void endColorChooser();
    virtual void didChooseColor(const Color&) OVERRIDE;
    virtual void didCleanup() OVERRIDE;

    void cleanupColorChooser();
    void updateColorSwatch();
    HTMLElement* shadowColorSwatch() const;

    OwnPtr<ColorChooser> m_chooser;
};

} // namespace WebCore



#include <wtf/StdLibExtras.h>

#if ENABLE(INPUT_COLOR)
#include "ColorChooser.h"
#include "ColorInputType.h"
#endif


{
    if (!m_inputType->isColorControl())
        return;
    static_cast<ColorInputType*>(m_inputType.get())->didChooseColor(color);
    if (!chooser)
        return;
    chooser->didChooseColor(color);
}
#endif
    

Lines 50-55 a/Source/WebCore/loader/EmptyClients.h_sec1
- a/Source/WebCore/loader/EmptyClients.h -3 / +5 lines
50	#include <v8.h>	50	#include <v8.h>
51	#endif	51	#endif
52		52
		53	#if ENABLE(INPUT_COLOR)
		54	#include "ColorChooser.h"
		55	#endif
		56
53	/*	57	/*
54	This file holds empty Client stubs for use by WebCore.	58	This file holds empty Client stubs for use by WebCore.
55	Viewless element needs to create a dummy Page->Frame->FrameView tree for use in parsing or executing JavaScript.	59	Viewless element needs to create a dummy Page->Frame->FrameView tree for use in parsing or executing JavaScript.
Lines 192-200 public: a/Source/WebCore/loader/EmptyClients.h_sec2
192	#endif	196	#endif
193		197
194	#if ENABLE(INPUT_COLOR)	198	#if ENABLE(INPUT_COLOR)
195	void openColorChooser(ColorChooser*, const Color&) { }	199	virtual PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) { return nullptr; }
196	void cleanupColorChooser(ColorChooser*) { }
197	void setSelectedColorInColorChooser(ColorChooser*, const Color&) { }
198	#endif	200	#endif
199		201
200	virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) { }	202	virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) { }



#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>

#if ENABLE(INPUT_COLOR)
#include "ColorChooser.h"
#include "ColorInputType.h"
#endif

#if ENABLE(SHARED_WORKERS)
#include "SharedWorkerRepository.h"
#endif



#endif

#if ENABLE(INPUT_COLOR)
PassOwnPtr<ColorChooser> Chrome::createColorChooser(ColorChooserClient* client, const Color& initialColor)
{
    return m_client->createColorChooser(client, initialColor);
}

void Chrome::cleanupColorChooser(ColorChooser* colorChooser)
{
    m_client->cleanupColorChooser(colorChooser);
}

void Chrome::setSelectedColorInColorChooser(ColorChooser* colorChooser, const Color& color)
{
    m_client->setSelectedColorInColorChooser(colorChooser, color);
}
#endif




    class ChromeClient;
#if ENABLE(INPUT_COLOR)
    class ColorChooser;
    class ColorChooserClient;
#endif
    class FileChooser;
    class FileIconLoader;

        void cancelGeolocationPermissionRequestForFrame(Frame*, Geolocation*);

#if ENABLE(INPUT_COLOR)
        PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color& initialColor);
        void cleanupColorChooser(ColorChooser*);
        void setSelectedColorInColorChooser(ColorChooser*, const Color&);
#endif

        void runOpenPanel(Frame*, PassRefPtr<FileChooser>);




#if ENABLE(INPUT_COLOR)
    class ColorChooser;
    class ColorChooserClient;
#endif

    class ChromeClient {

        virtual void cancelGeolocationPermissionRequestForFrame(Frame*, Geolocation*) = 0;

#if ENABLE(INPUT_COLOR)
        virtual PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) = 0;
        virtual void cleanupColorChooser(ColorChooser*) = 0;
        virtual void setSelectedColorInColorChooser(ColorChooser*, const Color&) = 0;
#endif

        virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) = 0;



#ifndef ColorChooser_h
#define ColorChooser_h

#include "Color.h"
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>

#if ENABLE(INPUT_COLOR)

namespace WebCore {

class Color;

class ColorChooser {
public:
    virtual ~ColorChooser() { }
    virtual void didChooseColor(const Color&) = 0;
    virtual void didCleanup() = 0;
    ColorChooser* chooser() { return m_chooser.get(); }

protected:
    ColorChooser* newColorChooser();
    void discardChooser();

private:
    RefPtr<ColorChooser> m_chooser;
};

class ColorChooser : public RefCounted<ColorChooser> {
public:
    static PassRefPtr<ColorChooser> create(ColorChooserClient*);
    ~ColorChooser();

    void disconnectClient() { m_client = 0; }

    void didChooseColor(const Color&);
    void didCleanup();

private:
    ColorChooser(ColorChooserClient*);

    virtual void setSelectedColor(const Color&) { }
    virtual void endChooser() { }
};

} // namespace WebCore



#ifndef ColorChooserClient_h
#define ColorChooserClient_h

#if ENABLE(INPUT_COLOR)

#include "ColorChooser.h"
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>

namespace WebCore {

class Color;

class ColorChooserClient {
public:
    virtual void didChooseColor(const Color&) = 0;
    virtual void didEndChooser() = 0;
};

} // namespace WebCore

#endif // ENABLE(INPUT_COLOR)

#endif // ColorChooserClient_h

Return to Bug 74591

Lines 31-36 a/Source/WebCore/html/ColorInputType.cpp_sec1
- a/Source/WebCore/html/ColorInputType.cpp -16 / +16 lines
31	#include "config.h"	31	#include "config.h"
32	#include "ColorInputType.h"	32	#include "ColorInputType.h"
33		33
		34	#include "CSSPropertyNames.h"
34	#include "Chrome.h"	35	#include "Chrome.h"
35	#include "Color.h"	36	#include "Color.h"
36	#include "HTMLDivElement.h"	37	#include "HTMLDivElement.h"
Lines 38-43 a/Source/WebCore/html/ColorInputType.cpp_sec2
38	#include "MouseEvent.h"	39	#include "MouseEvent.h"
39	#include "ScriptController.h"	40	#include "ScriptController.h"
40	#include "ShadowRoot.h"	41	#include "ShadowRoot.h"
		42
41	#include <wtf/PassOwnPtr.h>	43	#include <wtf/PassOwnPtr.h>
42	#include <wtf/text/WTFString.h>	44	#include <wtf/text/WTFString.h>
43		45
Lines 66-72 PassOwnPtr<InputType> ColorInputType::create(HTMLInputElement* element) a/Source/WebCore/html/ColorInputType.cpp_sec3
66		68
67	ColorInputType::~ColorInputType()	69	ColorInputType::~ColorInputType()
68	{	70	{
69	cleanupColorChooser();	71	endColorChooser();
70	}	72	}
71		73
72	bool ColorInputType::isColorControl() const	74	bool ColorInputType::isColorControl() const
Lines 126-134 void ColorInputType::setValue(const String& value, bool valueChanged, bool sendC a/Source/WebCore/html/ColorInputType.cpp_sec4
126	return;	128	return;
127		129
128	updateColorSwatch();	130	updateColorSwatch();
129	Chrome* chrome = this->chrome();	131	if (m_chooser)
130	if (chrome && chooser())	132	m_chooser->setSelectedColor(valueAsColor());
131	chrome->setSelectedColorInColorChooser(chooser(), valueAsColor());
132	}	133	}
133		134
134	void ColorInputType::handleDOMActivateEvent(Event* event)	135	void ColorInputType::handleDOMActivateEvent(Event* event)
Lines 139-152 void ColorInputType::handleDOMActivateEvent(Event* event) a/Source/WebCore/html/ColorInputType.cpp_sec5
139	if (!ScriptController::processingUserGesture())	140	if (!ScriptController::processingUserGesture())
140	return;	141	return;
141		142
142	if (Chrome* chrome = this->chrome())	143	Chrome* chrome = this->chrome();
143	chrome->openColorChooser(newColorChooser(), valueAsColor());	144	if (chrome && !m_chooser)
		145	m_chooser = chrome->createColorChooser(this, valueAsColor());
		146
144	event->setDefaultHandled();	147	event->setDefaultHandled();
145	}	148	}
146		149
147	void ColorInputType::detach()	150	void ColorInputType::detach()
148	{	151	{
149	cleanupColorChooser();	152	endColorChooser();
150	}	153	}
151		154
152	void ColorInputType::didChooseColor(const Color& color)	155	void ColorInputType::didChooseColor(const Color& color)
Lines 158-174 void ColorInputType::didChooseColor(const Color& color) a/Source/WebCore/html/ColorInputType.cpp_sec6
158	element()->dispatchFormControlChangeEvent();	161	element()->dispatchFormControlChangeEvent();
159	}	162	}
160		163
161	void ColorInputType::didCleanup()	164	void ColorInputType::didEndChooser()
162	{	165	{
163	discardChooser();	166	m_chooser.clear();
164	}	167	}
165		168
166	void ColorInputType::cleanupColorChooser()	169	void ColorInputType::endColorChooser()
167	{	170	{
168	Chrome* chrome = this->chrome();	171	if (m_chooser)
169	if (chrome && chooser())	172	m_chooser->endChooser();
170	chrome->cleanupColorChooser(chooser());
171	discardChooser();
172	}	173	}
173		174
174	void ColorInputType::updateColorSwatch()	175	void ColorInputType::updateColorSwatch()
Lines 177-184 void ColorInputType::updateColorSwatch() a/Source/WebCore/html/ColorInputType.cpp_sec7
177	if (!colorSwatch)	178	if (!colorSwatch)
178	return;	179	return;
179		180
180	ExceptionCode ec;	181	colorSwatch->style()->setProperty(CSSPropertyBackgroundColor, element()->value(), false, ASSERT_NO_EXCEPTION);
181	colorSwatch->style()->setProperty("background-color", element()->value(), ec);
182	}	182	}
183		183
184	HTMLElement* ColorInputType::shadowColorSwatch() const	184	HTMLElement* ColorInputType::shadowColorSwatch() const

Lines 57-63 a/Source/WebCore/html/HTMLInputElement.cpp_sec1
- a/Source/WebCore/html/HTMLInputElement.cpp -5 / +1 lines
57	#include <wtf/StdLibExtras.h>	57	#include <wtf/StdLibExtras.h>
58		58
59	#if ENABLE(INPUT_COLOR)	59	#if ENABLE(INPUT_COLOR)
60	#include "ColorChooser.h"
61	#include "ColorInputType.h"	60	#include "ColorInputType.h"
62	#endif	61	#endif
63		62
Lines 1542-1551 void HTMLInputElement::selectColorInColorChooser(const Color& color) a/Source/WebCore/html/HTMLInputElement.cpp_sec2
1542	{	1541	{
1543	if (!m_inputType->isColorControl())	1542	if (!m_inputType->isColorControl())
1544	return;	1543	return;
1545	RefPtr<ColorChooser> chooser = static_cast<ColorInputType*>(m_inputType.get())->chooser();	1544	static_cast<ColorInputType*>(m_inputType.get())->didChooseColor(color);
1546	if (!chooser)
1547	return;
1548	chooser->didChooseColor(color);
1549	}	1545	}
1550	#endif	1546	#endif
1551		1547

Lines 103-113 a/Source/WebCore/loader/FrameLoader.cpp_sec1
- a/Source/WebCore/loader/FrameLoader.cpp -5 lines
103	#include <wtf/text/CString.h>	103	#include <wtf/text/CString.h>
104	#include <wtf/text/WTFString.h>	104	#include <wtf/text/WTFString.h>
105		105
106	#if ENABLE(INPUT_COLOR)
107	#include "ColorChooser.h"
108	#include "ColorInputType.h"
109	#endif
110
111	#if ENABLE(SHARED_WORKERS)	106	#if ENABLE(SHARED_WORKERS)
112	#include "SharedWorkerRepository.h"	107	#include "SharedWorkerRepository.h"
113	#endif	108	#endif

Lines 458-476 void Chrome::enumerateChosenDirectory(FileChooser* fileChooser) a/Source/WebCore/page/Chrome.cpp_sec1
- a/Source/WebCore/page/Chrome.cpp -12 / +2 lines
458	#endif	458	#endif
459		459
460	#if ENABLE(INPUT_COLOR)	460	#if ENABLE(INPUT_COLOR)
461	void Chrome::openColorChooser(ColorChooser* colorChooser, const Color& initialColor)	461	PassOwnPtr<ColorChooser> Chrome::createColorChooser(ColorChooserClient* client, const Color& initialColor)
462	{	462	{
463	m_client->openColorChooser(colorChooser, initialColor);	463	return m_client->createColorChooser(client, initialColor);
464	}
465
466	void Chrome::cleanupColorChooser(ColorChooser* colorChooser)
467	{
468	m_client->cleanupColorChooser(colorChooser);
469	}
470
471	void Chrome::setSelectedColorInColorChooser(ColorChooser* colorChooser, const Color& color)
472	{
473	m_client->setSelectedColorInColorChooser(colorChooser, color);
474	}	464	}
475	#endif	465	#endif
476		466

Lines 38-43 namespace WebCore { a/Source/WebCore/page/Chrome.h_sec1
- a/Source/WebCore/page/Chrome.h -3 / +2 lines
38	class ChromeClient;	38	class ChromeClient;
39	#if ENABLE(INPUT_COLOR)	39	#if ENABLE(INPUT_COLOR)
40	class ColorChooser;	40	class ColorChooser;
		41	class ColorChooserClient;
41	#endif	42	#endif
42	class FileChooser;	43	class FileChooser;
43	class FileIconLoader;	44	class FileIconLoader;
Lines 153-161 namespace WebCore { a/Source/WebCore/page/Chrome.h_sec2
153	void cancelGeolocationPermissionRequestForFrame(Frame, Geolocation);	154	void cancelGeolocationPermissionRequestForFrame(Frame, Geolocation);
154		155
155	#if ENABLE(INPUT_COLOR)	156	#if ENABLE(INPUT_COLOR)
156	void openColorChooser(ColorChooser*, const Color&);	157	PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color& initialColor);
157	void cleanupColorChooser(ColorChooser*);
158	void setSelectedColorInColorChooser(ColorChooser*, const Color&);
159	#endif	158	#endif
160		159
161	void runOpenPanel(Frame*, PassRefPtr<FileChooser>);	160	void runOpenPanel(Frame*, PassRefPtr<FileChooser>);

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +36 lines
		1	2011-12-14 Keishi Hattori <keishi@webkit.org>
		2
		3	Refactor input type color WebCore part
		4	https://bugs.webkit.org/show_bug.cgi?id=74591
		5
		6	Reviewed by Kent Tamura.
		7
		8	Changing ColorChooser to address issues raised in Bug 65897.
		9	Chrome::createColorChooser will return a WebCore::ColorChooser instance
		10	so the WebCore side (ColorInputType) and call the WebKit side. We pass the ColorChooserClient as an argument
		11	to Chrome::createColorChooser so the WebKit side can call callbacks, didEndChooser and didChooseColor.
		12
		13	* html/ColorInputType.cpp:
		14	(WebCore::ColorInputType::~ColorInputType):
		15	(WebCore::ColorInputType::setValue):
		16	(WebCore::ColorInputType::handleDOMActivateEvent): Calls createColorChooser to open the color chooser.
		17	(WebCore::ColorInputType::detach):
		18	(WebCore::ColorInputType::didEndChooser): Release the ColorChooser object.
		19	(WebCore::ColorInputType::endColorChooser):
		20	(WebCore::ColorInputType::updateColorSwatch): Added argument so it will compile again.
		21	* html/ColorInputType.h:
		22	* html/HTMLInputElement.cpp:
		23	(WebCore::HTMLInputElement::selectColorInColorChooser):
		24	* loader/EmptyClients.h:
		25	(WebCore::EmptyChromeClient::createColorChooser):
		26	* loader/FrameLoader.cpp:
		27	* page/Chrome.cpp:
		28	(WebCore::Chrome::createColorChooser): Opens the color chooser. Returns a ColorChooser PassOwnPtr.
		29	* page/Chrome.h:
		30	* page/ChromeClient.h:
		31	* platform/ColorChooser.h:
		32	(WebCore::ColorChooser::~ColorChooser):
		33	(WebCore::ColorChooser::setSelectedColor):
		34	(WebCore::ColorChooser::endChooser):
		35	* platform/ColorChooserClient.h: Added.
		36
1	2011-12-14 Kenneth Russell <kbr@google.com>	37	2011-12-14 Kenneth Russell <kbr@google.com>
2		38
3	Unreviewed, rolling out r102816.	39	Unreviewed, rolling out r102816.

Lines 31-37 a/Source/WebCore/html/ColorInputType.h_sec1
- a/Source/WebCore/html/ColorInputType.h -6 / +8 lines
31	#ifndef ColorInputType_h	31	#ifndef ColorInputType_h
32	#define ColorInputType_h	32	#define ColorInputType_h
33		33
34	#include "ColorChooser.h"	34	#include "ColorChooserClient.h"
35	#include "InputType.h"	35	#include "InputType.h"
36		36
37	#if ENABLE(INPUT_COLOR)	37	#if ENABLE(INPUT_COLOR)
Lines 43-48 public: a/Source/WebCore/html/ColorInputType.h_sec2
43	static PassOwnPtr<InputType> create(HTMLInputElement*);	43	static PassOwnPtr<InputType> create(HTMLInputElement*);
44	virtual ~ColorInputType();	44	virtual ~ColorInputType();
45		45
		46	// ColorChooserClient implementation.
		47	virtual void didChooseColor(const Color&) OVERRIDE;
		48	virtual void didEndChooser() OVERRIDE;
		49
46	private:	50	private:
47	ColorInputType(HTMLInputElement* element) : InputType(element) { }	51	ColorInputType(HTMLInputElement* element) : InputType(element) { }
48	virtual bool isColorControl() const;	52	virtual bool isColorControl() const;
Lines 56-68 private: a/Source/WebCore/html/ColorInputType.h_sec3
56	virtual void handleDOMActivateEvent(Event*);	60	virtual void handleDOMActivateEvent(Event*);
57	virtual void detach();	61	virtual void detach();
58		62
59	// ColorChooserClient implementation.	63	void endColorChooser();
60	virtual void didChooseColor(const Color&) OVERRIDE;
61	virtual void didCleanup() OVERRIDE;
62
63	void cleanupColorChooser();
64	void updateColorSwatch();	64	void updateColorSwatch();
65	HTMLElement* shadowColorSwatch() const;	65	HTMLElement* shadowColorSwatch() const;
		66
		67	OwnPtr<ColorChooser> m_chooser;
66	};	68	};
67		69
68	} // namespace WebCore	70	} // namespace WebCore

Lines 73-78 namespace WebCore { a/Source/WebCore/page/ChromeClient.h_sec1
- a/Source/WebCore/page/ChromeClient.h -3 / +2 lines
73		73
74	#if ENABLE(INPUT_COLOR)	74	#if ENABLE(INPUT_COLOR)
75	class ColorChooser;	75	class ColorChooser;
		76	class ColorChooserClient;
76	#endif	77	#endif
77		78
78	class ChromeClient {	79	class ChromeClient {
Lines 219-227 namespace WebCore { a/Source/WebCore/page/ChromeClient.h_sec2
219	virtual void cancelGeolocationPermissionRequestForFrame(Frame, Geolocation) = 0;	220	virtual void cancelGeolocationPermissionRequestForFrame(Frame, Geolocation) = 0;
220		221
221	#if ENABLE(INPUT_COLOR)	222	#if ENABLE(INPUT_COLOR)
222	virtual void openColorChooser(ColorChooser*, const Color&) = 0;	223	virtual PassOwnPtr<ColorChooser> createColorChooser(ColorChooserClient*, const Color&) = 0;
223	virtual void cleanupColorChooser(ColorChooser*) = 0;
224	virtual void setSelectedColorInColorChooser(ColorChooser*, const Color&) = 0;
225	#endif	224	#endif
226		225
227	virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) = 0;	226	virtual void runOpenPanel(Frame*, PassRefPtr<FileChooser>) = 0;

Lines 30-74 a/Source/WebCore/platform/ColorChooser.h_sec1
- a/Source/WebCore/platform/ColorChooser.h -32 / +5 lines
30	#ifndef ColorChooser_h	30	#ifndef ColorChooser_h
31	#define ColorChooser_h	31	#define ColorChooser_h
32		32
33	#include "Color.h"
34	#include <wtf/RefCounted.h>
35	#include <wtf/RefPtr.h>
36
37	#if ENABLE(INPUT_COLOR)	33	#if ENABLE(INPUT_COLOR)
38		34
39	namespace WebCore {	35	namespace WebCore {
40		36
41	class ColorChooser;	37	class Color;
42		38
43	class ColorChooserClient {	39	class ColorChooser {
44	public:	40	public:
45	virtual ~ColorChooserClient();	41	virtual ~ColorChooser() { }
46	virtual void didChooseColor(const Color&) = 0;
47	virtual void didCleanup() = 0;
48	ColorChooser* chooser() { return m_chooser.get(); }
49
50	protected:
51	ColorChooser* newColorChooser();
52	void discardChooser();
53
54	private:
55	RefPtr<ColorChooser> m_chooser;
56	};
57
58	class ColorChooser : public RefCounted<ColorChooser> {
59	public:
60	static PassRefPtr<ColorChooser> create(ColorChooserClient*);
61	~ColorChooser();
62
63	void disconnectClient() { m_client = 0; }
64
65	void didChooseColor(const Color&);
66	void didCleanup();
67
68	private:
69	ColorChooser(ColorChooserClient*);
70		42
71	ColorChooserClient* m_client;	43	virtual void setSelectedColor(const Color&) { }
		44	virtual void endChooser() { }
72	};	45	};
73		46
74	} // namespace WebCore	47	} // namespace WebCore

Line 0 a/Source/WebCore/platform/ColorChooserClient.h_sec1
- a/Source/WebCore/platform/ColorChooserClient.h +24 lines
	1	#ifndef ColorChooserClient_h
	2	#define ColorChooserClient_h
	3
	4	#if ENABLE(INPUT_COLOR)
	5
	6	#include "ColorChooser.h"
	7	#include <wtf/OwnPtr.h>
	8	#include <wtf/PassOwnPtr.h>
	9
	10	namespace WebCore {
	11
	12	class Color;
	13
	14	class ColorChooserClient {
	15	public:
	16	virtual void didChooseColor(const Color&) = 0;
	17	virtual void didEndChooser() = 0;
	18	};
	19
	20	} // namespace WebCore
	21
	22	#endif // ENABLE(INPUT_COLOR)
	23
	24	#endif // ColorChooserClient_h