+2012-04-06 Peter Rybin <peter.rybin@gmail.com>
+
+ Web Inspector: CodeGeneratorInspector.py: stop accepting raw InspectorObject in generated setters
+ https://bugs.webkit.org/show_bug.cgi?id=83327
+
+ Reviewed by Pavel Feldman.
+
+ Generator fixed to have strict types in generated setter methods.
+
+ Client code is switched from InspectorObject's and String's to generated types where
+ needed.
+
+ * inspector/CodeGeneratorInspector.py:
+ (AdHocTypeContext):
+ (format_setter_value_expression):
+ * inspector/ConsoleMessage.cpp:
+ (WebCore::messageSourceValue):
+ (WebCore::messageTypeValue):
+ (WebCore::messageLevelValue):
+ (WebCore::ConsoleMessage::addToFrontend):
+ * inspector/InspectorApplicationCacheAgent.cpp:
+ (WebCore::InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources):
+ (WebCore::InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource):
+ * inspector/InspectorApplicationCacheAgent.h:
+ (InspectorApplicationCacheAgent):
+ * inspector/InspectorCSSAgent.cpp:
+ (WebCore::InspectorCSSAgent::asInspectorStyleSheet):
+ (WebCore::InspectorCSSAgent::viaInspectorStyleSheet):
+ (WebCore::InspectorCSSAgent::detectOrigin):
+ * inspector/InspectorCSSAgent.h:
+ (InspectorCSSAgent):
+ * inspector/InspectorDOMAgent.cpp:
+ (WebCore::InspectorDOMAgent::buildObjectForNode):
+ * inspector/InspectorIndexedDBAgent.cpp:
+ (WebCore):
+ * inspector/InspectorMemoryAgent.cpp:
+ * inspector/InspectorPageAgent.cpp:
+ (WebCore::InspectorPageAgent::buildObjectForFrameTree):
+ * inspector/InspectorResourceAgent.cpp:
+ (WebCore::buildObjectForTiming):
+ (WebCore::buildObjectForCachedResource):
+ * inspector/InspectorStyleSheet.cpp:
+ (WebCore::InspectorStyle::buildObjectForStyle):
+ (WebCore::InspectorStyleSheet::create):
+ (WebCore::InspectorStyleSheet::InspectorStyleSheet):
+ (WebCore::InspectorStyleSheet::buildObjectForRule):
+ (WebCore::InspectorStyleSheet::resourceStyleSheetText):
+ (WebCore::InspectorStyleSheet::buildArrayForRuleList):
+ (WebCore::InspectorStyleSheetForInlineStyle::create):
+ (WebCore::InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle):
+ * inspector/InspectorStyleSheet.h:
+ (InspectorCSSId):
+ (WebCore::InspectorCSSId::asProtocolValue): method is made template as now it returns 2 formally different types.
+ (InspectorStyleSheet):
+ (WebCore::InspectorStyleSheet::canBind):
+ (InspectorStyleSheetForInlineStyle):
+
+2012-04-06 Pavel Feldman <pfeldman@chromium.org>
+
+ Web Inspector: highlight diff in the gutter, not in the line content.
+ https://bugs.webkit.org/show_bug.cgi?id=83371
+
+ Reviewed by Yury Semikhatsky.
+
+ Now that the editing mode is enabled by default, diff highlighting gets annoying.
+ I am moving it to the gutter (same decoration as before, but now coloring gutter only).
+
+ * inspector/front-end/TextViewer.js:
+ (WebInspector.TextEditorGutterPanel.prototype.textChanged):
+ * inspector/front-end/textViewer.css:
+ (.diff-container .webkit-added-line.webkit-line-number):
+ (.diff-container .webkit-removed-line.webkit-line-number):
+ (.diff-container .webkit-changed-line.webkit-line-number):
+
2012-04-06 Pavel Feldman <pfeldman@chromium.org>
Web Inspector: highlight diff in the gutter, not in the line content.
param_type_binding = prop_data.param_type_binding
param_raw_type = param_type_binding.reduce_to_raw_type()
- for param_type_opt in MethodGenerateModes.get_modes(param_type_binding):
- writer.newline_multiline("""
+
+ writer.newline_multiline("""
Builder<STATE | %s>& set%s(%s value)
{
COMPILE_ASSERT(!(STATE & %s), property_%s_already_set);
return castState<%s>();
}
"""
- % (state_enum_items[pos],
- Capitalizer.lower_camel_case_to_upper(prop_name),
- param_type_opt.get_c_param_type_text(param_type_binding),
- state_enum_items[pos], prop_name,
- param_raw_type.get_setter_name(), prop_name,
- param_type_opt.get_setter_value_expression(param_type_binding, "value"),
- state_enum_items[pos]))
+ % (state_enum_items[pos],
+ Capitalizer.lower_camel_case_to_upper(prop_name),
+ param_type_binding.get_type_model().get_input_param_type_text(),
+ state_enum_items[pos], prop_name,
+ param_raw_type.get_setter_name(), prop_name,
+ format_setter_value_expression(param_type_binding, "value"),
+ state_enum_items[pos]))
pos += 1
param_type_binding = prop_data.param_type_binding
setter_name = "set%s" % Capitalizer.lower_camel_case_to_upper(prop_name)
- for param_type_opt in MethodGenerateModes.get_modes(param_type_binding):
- writer.append_multiline("\n void %s" % setter_name)
- writer.append("(%s value)\n" % param_type_opt.get_c_param_type_text(param_type_binding))
- writer.newline(" {\n")
- writer.newline(" this->set%s(\"%s\", %s);\n"
- % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop_data.p["name"],
- param_type_opt.get_setter_value_expression(param_type_binding, "value")))
- writer.newline(" }\n")
+ writer.append_multiline("\n void %s" % setter_name)
+ writer.append("(%s value)\n" % param_type_binding.get_type_model().get_input_param_type_text())
+ writer.newline(" {\n")
+ writer.newline(" this->set%s(\"%s\", %s);\n"
+ % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop_data.p["name"],
+ format_setter_value_expression(param_type_binding, "value")))
+ writer.newline(" }\n")
if setter_name in INSPECTOR_OBJECT_SETTER_NAMES:
class AdHocTypeContext:
container_full_name_prefix = "<not yet defined>"
- container_relative_name_prefix = "<not yet defined>"
+ container_relative_name_prefix = ""
@staticmethod
def get_type_name_fix():
return raw_type
-# Chooses method generate modes for a particular type. A particular setter
-# can be generated as one method with a simple parameter type,
-# as one method with a raw type name and commented annotation about expected
-# specialized type name or as overloaded method when raw and specialized
-# parameter types require different behavior.
-class MethodGenerateModes:
- @classmethod
- def get_modes(cls, type_binding):
- if type_binding.get_setter_value_expression_pattern():
- # In raw and strict modes method code is actually different.
- return [cls.StrictParameterMode, cls.RawParameterMode]
- else:
- # In raw and strict modes method code is the same.
- # Only put strict parameter type in comments.
- return [cls.CombinedMode]
-
- class StrictParameterMode:
- @staticmethod
- def get_c_param_type_text(type_binding):
- return type_binding.get_type_model().get_input_param_type_text()
-
- @staticmethod
- def get_setter_value_expression(param_type_binding, value_ref):
- pattern = param_type_binding.get_setter_value_expression_pattern()
- if pattern:
- return pattern % value_ref
- else:
- return value_ref
-
- class RawParameterMode:
- @staticmethod
- def get_c_param_type_text(type_binding):
- return type_binding.reduce_to_raw_type().get_raw_type_model().get_input_param_type_text()
-
- @staticmethod
- def get_setter_value_expression(param_type_binding, value_ref):
- return value_ref
-
- class CombinedMode:
- @staticmethod
- def get_c_param_type_text(type_binding):
- return get_annotated_type_text(type_binding.reduce_to_raw_type().get_raw_type_model().get_input_param_type_text(),
- type_binding.get_type_model().get_input_param_type_text())
-
- @staticmethod
- def get_setter_value_expression(param_type_binding, value_ref):
- pattern = param_type_binding.get_setter_value_expression_pattern()
- if pattern:
- return pattern % value_ref
- else:
- return value_ref
+def format_setter_value_expression(param_type_binding, value_ref):
+ pattern = param_type_binding.get_setter_value_expression_pattern()
+ if pattern:
+ return pattern % value_ref
+ else:
+ return value_ref
class Generator:
frontend_class_field_lines = []
}
// Keep in sync with inspector/front-end/ConsoleView.js
-static String messageSourceValue(MessageSource source)
+static TypeBuilder::Console::ConsoleMessage::Source::Enum messageSourceValue(MessageSource source)
{
switch (source) {
- case HTMLMessageSource: return "html";
- case XMLMessageSource: return "xml";
- case JSMessageSource: return "javascript";
- case NetworkMessageSource: return "network";
- case ConsoleAPIMessageSource: return "console-api";
- case OtherMessageSource: return "other";
+ case HTMLMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Html;
+ case XMLMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Xml;
+ case JSMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Javascript;
+ case NetworkMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Network;
+ case ConsoleAPIMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Console_api;
+ case OtherMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Other;
}
- return "other";
+ return TypeBuilder::Console::ConsoleMessage::Source::Other;
}
-static String messageTypeValue(MessageType type)
+static TypeBuilder::Console::ConsoleMessage::Type::Enum messageTypeValue(MessageType type)
{
switch (type) {
- case LogMessageType: return "log";
- case DirMessageType: return "dir";
- case DirXMLMessageType: return "dirXML";
- case TraceMessageType: return "trace";
- case StartGroupMessageType: return "startGroup";
- case StartGroupCollapsedMessageType: return "startGroupCollapsed";
- case EndGroupMessageType: return "endGroup";
- case AssertMessageType: return "assert";
+ case LogMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Log;
+ case DirMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Dir;
+ case DirXMLMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Dirxml;
+ case TraceMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Trace;
+ case StartGroupMessageType: return TypeBuilder::Console::ConsoleMessage::Type::StartGroup;
+ case StartGroupCollapsedMessageType: return TypeBuilder::Console::ConsoleMessage::Type::StartGroupCollapsed;
+ case EndGroupMessageType: return TypeBuilder::Console::ConsoleMessage::Type::EndGroup;
+ case AssertMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Assert;
}
- return "log";
+ return TypeBuilder::Console::ConsoleMessage::Type::Log;
}
-static String messageLevelValue(MessageLevel level)
+static TypeBuilder::Console::ConsoleMessage::Level::Enum messageLevelValue(MessageLevel level)
{
switch (level) {
- case TipMessageLevel: return "tip";
- case LogMessageLevel: return "log";
- case WarningMessageLevel: return "warning";
- case ErrorMessageLevel: return "error";
- case DebugMessageLevel: return "debug";
+ case TipMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Tip;
+ case LogMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Log;
+ case WarningMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Warning;
+ case ErrorMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Error;
+ case DebugMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Debug;
}
- return "log";
+ return TypeBuilder::Console::ConsoleMessage::Level::Log;
}
void ConsoleMessage::addToFrontend(InspectorFrontend::Console* frontend, InjectedScriptManager* injectedScriptManager)
if (m_arguments && m_arguments->argumentCount()) {
InjectedScript injectedScript = injectedScriptManager->injectedScriptFor(m_arguments->globalState());
if (!injectedScript.hasNoValue()) {
- RefPtr<InspectorArray> jsonArgs = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject> > jsonArgs = TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject>::create();
for (unsigned i = 0; i < m_arguments->argumentCount(); ++i) {
- RefPtr<InspectorValue> inspectorValue = injectedScript.wrapObject(m_arguments->argumentAt(i), "console");
+ RefPtr<TypeBuilder::Runtime::RemoteObject> inspectorValue = injectedScript.wrapObject(m_arguments->argumentAt(i), "console");
if (!inspectorValue) {
ASSERT_NOT_REACHED();
return;
}
- jsonArgs->pushValue(inspectorValue);
+ jsonArgs->addItem(inspectorValue);
}
jsonObj->setParameters(jsonArgs);
}
.setResources(buildArrayForApplicationCacheResources(applicationCacheResources));
}
-PassRefPtr<InspectorArray> InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList& applicationCacheResources)
+PassRefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource> > InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList& applicationCacheResources)
{
- RefPtr<InspectorArray> resources = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource> > resources = TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource>::create();
ApplicationCacheHost::ResourceInfoList::const_iterator end = applicationCacheResources.end();
ApplicationCacheHost::ResourceInfoList::const_iterator it = applicationCacheResources.begin();
for (int i = 0; it != end; ++it, i++)
- resources->pushObject(buildObjectForApplicationCacheResource(*it));
+ resources->addItem(buildObjectForApplicationCacheResource(*it));
return resources;
}
-PassRefPtr<InspectorObject> InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo& resourceInfo)
+PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo& resourceInfo)
{
- RefPtr<InspectorObject> value = InspectorObject::create();
- value->setString("url", resourceInfo.m_resource.string());
- value->setNumber("size", resourceInfo.m_size);
-
String types;
if (resourceInfo.m_isMaster)
types.append("Master ");
if (resourceInfo.m_isExplicit)
types.append("Explicit ");
- value->setString("type", types);
+ RefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> value = TypeBuilder::ApplicationCache::ApplicationCacheResource::create()
+ .setUrl(resourceInfo.m_resource.string())
+ .setSize(resourceInfo.m_size)
+ .setType(types);
return value;
}
private:
InspectorApplicationCacheAgent(InstrumentingAgents*, InspectorState*, InspectorPageAgent*);
PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCache> buildObjectForApplicationCache(const ApplicationCacheHost::ResourceInfoList&, const ApplicationCacheHost::CacheInfo&);
- PassRefPtr<InspectorArray> buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList&);
- PassRefPtr<InspectorObject> buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo&);
+ PassRefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource> > buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList&);
+ PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo&);
DocumentLoader* assertFrameWithDocumentLoader(ErrorString*, String frameId);
return 0;
String newStyleSheetId = String::number(m_lastStyleSheetId++);
- RefPtr<InspectorStyleSheetForInlineStyle> inspectorStyleSheet = InspectorStyleSheetForInlineStyle::create(newStyleSheetId, element, "regular", this);
+ RefPtr<InspectorStyleSheetForInlineStyle> inspectorStyleSheet = InspectorStyleSheetForInlineStyle::create(newStyleSheetId, element, TypeBuilder::CSS::CSSRule::Origin::Regular, this);
m_idToInspectorStyleSheet.set(newStyleSheetId, inspectorStyleSheet);
m_nodeToInspectorStyleSheet.set(element, inspectorStyleSheet);
return inspectorStyleSheet.get();
return 0;
CSSStyleSheet* cssStyleSheet = static_cast<CSSStyleSheet*>(styleSheet);
String id = String::number(m_lastStyleSheetId++);
- inspectorStyleSheet = InspectorStyleSheet::create(id, cssStyleSheet, "inspector", InspectorDOMAgent::documentURLString(document), this);
+ inspectorStyleSheet = InspectorStyleSheet::create(id, cssStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Inspector, InspectorDOMAgent::documentURLString(document), this);
m_idToInspectorStyleSheet.set(id, inspectorStyleSheet);
m_cssStyleSheetToInspectorStyleSheet.set(cssStyleSheet, inspectorStyleSheet);
m_documentToInspectorStyleSheet.set(document, inspectorStyleSheet);
return it->second.get();
}
-String InspectorCSSAgent::detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument)
+TypeBuilder::CSS::CSSRule::Origin::Enum InspectorCSSAgent::detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument)
{
- DEFINE_STATIC_LOCAL(String, userAgent, ("user-agent"));
- DEFINE_STATIC_LOCAL(String, user, ("user"));
- DEFINE_STATIC_LOCAL(String, inspector, ("inspector"));
-
- String origin("regular");
+ TypeBuilder::CSS::CSSRule::Origin::Enum origin = TypeBuilder::CSS::CSSRule::Origin::Regular;
if (pageStyleSheet && !pageStyleSheet->ownerNode() && pageStyleSheet->href().isEmpty())
- origin = userAgent;
+ origin = TypeBuilder::CSS::CSSRule::Origin::User_agent;
else if (pageStyleSheet && pageStyleSheet->ownerNode() && pageStyleSheet->ownerNode()->nodeName() == "#document")
- origin = user;
+ origin = TypeBuilder::CSS::CSSRule::Origin::User;
else {
InspectorStyleSheet* viaInspectorStyleSheetForOwner = viaInspectorStyleSheet(ownerDocument, false);
if (viaInspectorStyleSheetForOwner && pageStyleSheet == viaInspectorStyleSheetForOwner->pageStyleSheet())
- origin = inspector;
+ origin = TypeBuilder::CSS::CSSRule::Origin::Inspector;
}
return origin;
}
InspectorStyleSheet* bindStyleSheet(CSSStyleSheet*);
InspectorStyleSheet* viaInspectorStyleSheet(Document*, bool createIfAbsent);
InspectorStyleSheet* assertStyleSheetForId(ErrorString*, const String&);
- String detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument);
+ TypeBuilder::CSS::CSSRule::Origin::Enum detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument);
PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > buildArrayForRuleList(CSSRuleList*, CSSStyleSelector*);
PassRefPtr<TypeBuilder::CSS::CSSStyle> buildObjectForAttributesStyle(Element*);
if (node->isContainerNode()) {
int nodeCount = innerChildNodeCount(node);
value->setChildNodeCount(nodeCount);
- RefPtr<InspectorArray> children = buildArrayForContainerChildren(node, depth, nodesMap);
+ RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = buildArrayForContainerChildren(node, depth, nodesMap);
if (children->length() > 0)
value->setChildren(children.release());
}
value->setContentDocument(buildObjectForNode(doc, 0, nodesMap));
}
if (element->hasShadowRoot()) {
- RefPtr<InspectorArray> shadowRoots = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > shadowRoots = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
for (ShadowRoot* root = element->shadowTree()->youngestShadowRoot(); root; root = root->olderShadowRoot())
- shadowRoots->pushObject(buildObjectForNode(root, 0, nodesMap));
+ shadowRoots->addItem(buildObjectForNode(root, 0, nodesMap));
value->setShadowRoots(shadowRoots);
}
} else if (node->isDocumentNode()) {
if (!m_frontendProvider->frontend())
return;
- RefPtr<InspectorArray> databaseNames = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<String> > databaseNames = TypeBuilder::Array<String>::create();
for (size_t i = 0; i < databaseNamesList->length(); ++i)
- databaseNames->pushString(databaseNamesList->item(i));
+ databaseNames->addItem(databaseNamesList->item(i));
RefPtr<SecurityOriginWithDatabaseNames> result = SecurityOriginWithDatabaseNames::create()
.setSecurityOrigin(m_securityOrigin)
if (!m_frontendProvider->frontend())
return;
- RefPtr<InspectorArray> objectStores = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStore> > objectStores = TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStore>::create();
RefPtr<DOMStringList> objectStoreNamesList = idbDatabase->objectStoreNames();
for (size_t i = 0; i < objectStoreNamesList->length(); ++i) {
if (!idbObjectStore)
continue;
- RefPtr<InspectorArray> indexes = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStoreIndex> > indexes = TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStoreIndex>::create();
RefPtr<DOMStringList> indexNamesList = idbObjectStore->indexNames();
for (size_t j = 0; j < indexNamesList->length(); ++j) {
RefPtr<IDBIndexBackendInterface> idbIndex = indexForObjectStore(idbObjectStore.get(), indexNamesList->item(j));
.setKeyPath(idbIndex->keyPath())
.setUnique(idbIndex->unique())
.setMultiEntry(idbIndex->multiEntry());
- indexes->pushObject(objectStoreIndex);
+ indexes->addItem(objectStoreIndex);
}
RefPtr<ObjectStore> objectStore = ObjectStore::create()
.setName(idbObjectStore->name())
.setKeyPath(idbObjectStore->keyPath())
.setIndexes(indexes);
- objectStores->pushObject(objectStore);
+ objectStores->addItem(objectStore);
}
RefPtr<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
.setName(idbDatabase->name())
case IDBKey::ArrayType: {
RefPtr<Key> tmpKey = Key::create().setType(Key::Type::Array);
key = tmpKey;
- RefPtr<InspectorArray> array = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::Key> > array = TypeBuilder::Array<TypeBuilder::IndexedDB::Key>::create();
IDBKey::KeyArray keyArray = idbKey->array();
for (size_t i = 0; i < keyArray.size(); ++i)
- array->pushObject(keyFromIDBKey(keyArray[i].get()));
+ array->addItem(keyFromIDBKey(keyArray[i].get()));
key->setArray(array);
break;
}
RefPtr<IDBKey> key = m_idbCursor->key();
RefPtr<IDBKey> primaryKey = m_idbCursor->primaryKey();
RefPtr<SerializedScriptValue> value = m_idbCursor->value();
- RefPtr<InspectorObject> wrappedValue = m_injectedScript.wrapSerializedObject(value.get(), String());
+ RefPtr<TypeBuilder::Runtime::RemoteObject> wrappedValue = m_injectedScript.wrapSerializedObject(value.get(), String());
RefPtr<DataEntry> dataEntry = DataEntry::create()
.setKey(keyFromIDBKey(key.get()))
.setPrimaryKey(keyFromIDBKey(primaryKey.get()))
int totalNodeCount() { return m_totalNodeCount; }
- PassRefPtr<InspectorArray> nodeCount()
+ PassRefPtr<TypeBuilder::Array<TypeBuilder::Memory::NodeCount> > nodeCount()
{
- RefPtr<InspectorArray> childrenStats = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::Memory::NodeCount> > childrenStats = TypeBuilder::Array<TypeBuilder::Memory::NodeCount>::create();
for (HashMap<String, int>::iterator it = m_nodeNameToCount.begin(); it != m_nodeNameToCount.end(); ++it) {
RefPtr<NodeCount> nodeCount = NodeCount::create().setNodeName(it->first)
.setCount(it->second);
- childrenStats->pushObject(nodeCount);
+ childrenStats->addItem(nodeCount);
}
return childrenStats.release();
}
- PassRefPtr<InspectorArray> listenerCount()
+ PassRefPtr<TypeBuilder::Array<TypeBuilder::Memory::ListenerCount> > listenerCount()
{
- RefPtr<InspectorArray> listenerStats = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::Memory::ListenerCount> > listenerStats = TypeBuilder::Array<TypeBuilder::Memory::ListenerCount>::create();
for (HashMap<AtomicString, int>::iterator it = m_eventTypeToCount.begin(); it != m_eventTypeToCount.end(); ++it) {
RefPtr<ListenerCount> listenerCount = ListenerCount::create().setType(it->first)
.setCount(it->second);
- listenerStats->pushObject(listenerCount);
+ listenerStats->addItem(listenerCount);
}
return listenerStats.release();
}
PassRefPtr<TypeBuilder::Page::FrameResourceTree> InspectorPageAgent::buildObjectForFrameTree(Frame* frame)
{
- RefPtr<InspectorObject> frameObject = buildObjectForFrame(frame);
+ RefPtr<TypeBuilder::Page::Frame> frameObject = buildObjectForFrame(frame);
RefPtr<TypeBuilder::Array<TypeBuilder::Page::FrameResourceTree::Resources> > subresources = TypeBuilder::Array<TypeBuilder::Page::FrameResourceTree::Resources>::create();
RefPtr<TypeBuilder::Page::FrameResourceTree> result = TypeBuilder::Page::FrameResourceTree::create()
.setFrame(frameObject)
return headersObject;
}
-static PassRefPtr<InspectorObject> buildObjectForTiming(const ResourceLoadTiming& timing, DocumentLoader* loader)
-{
- RefPtr<InspectorObject> timingObject = InspectorObject::create();
- timingObject->setNumber("requestTime", timing.convertResourceLoadTimeToDocumentTime(loader->timing(), 0));
- timingObject->setNumber("proxyStart", timing.proxyStart);
- timingObject->setNumber("proxyEnd", timing.proxyEnd);
- timingObject->setNumber("dnsStart", timing.dnsStart);
- timingObject->setNumber("dnsEnd", timing.dnsEnd);
- timingObject->setNumber("connectStart", timing.connectStart);
- timingObject->setNumber("connectEnd", timing.connectEnd);
- timingObject->setNumber("sslStart", timing.sslStart);
- timingObject->setNumber("sslEnd", timing.sslEnd);
- timingObject->setNumber("sendStart", timing.sendStart);
- timingObject->setNumber("sendEnd", timing.sendEnd);
- timingObject->setNumber("receiveHeadersEnd", timing.receiveHeadersEnd);
- return timingObject;
+static PassRefPtr<TypeBuilder::Network::ResourceTiming> buildObjectForTiming(const ResourceLoadTiming& timing, DocumentLoader* loader)
+{
+ return TypeBuilder::Network::ResourceTiming::create()
+ .setRequestTime(timing.convertResourceLoadTimeToDocumentTime(loader->timing(), 0))
+ .setProxyStart(timing.proxyStart)
+ .setProxyEnd(timing.proxyEnd)
+ .setDnsStart(timing.dnsStart)
+ .setDnsEnd(timing.dnsEnd)
+ .setConnectStart(timing.connectStart)
+ .setConnectEnd(timing.connectEnd)
+ .setSslStart(timing.sslStart)
+ .setSslEnd(timing.sslEnd)
+ .setSendStart(timing.sendStart)
+ .setSendEnd(timing.sendEnd)
+ .setReceiveHeadersEnd(timing.receiveHeadersEnd);
}
static PassRefPtr<TypeBuilder::Network::Request> buildObjectForResourceRequest(const ResourceRequest& request)
.setUrl(cachedResource.url())
.setType(InspectorPageAgent::cachedResourceTypeJson(cachedResource))
.setBodySize(cachedResource.encodedSize());
- RefPtr<InspectorObject> resourceResponse = buildObjectForResourceResponse(cachedResource.response(), loader);
+ RefPtr<TypeBuilder::Network::Response> resourceResponse = buildObjectForResourceResponse(cachedResource.response(), loader);
if (resourceResponse)
resourceObject->setResponse(resourceResponse);
return resourceObject;
{
RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
if (!m_styleId.isEmpty())
- result->setStyleId(m_styleId.asProtocolValue());
+ result->setStyleId(m_styleId.asProtocolValue<TypeBuilder::CSS::CSSStyleId>());
result->setWidth(m_style->getPropertyValue("width"));
result->setHeight(m_style->getPropertyValue("height"));
return m_format;
}
-PassRefPtr<InspectorStyleSheet> InspectorStyleSheet::create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener* listener)
+PassRefPtr<InspectorStyleSheet> InspectorStyleSheet::create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum origin, const String& documentURL, Listener* listener)
{
return adoptRef(new InspectorStyleSheet(id, pageStyleSheet, origin, documentURL, listener));
}
return emptyString();
}
-InspectorStyleSheet::InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener* listener)
+InspectorStyleSheet::InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum origin, const String& documentURL, Listener* listener)
: m_id(id)
, m_pageStyleSheet(pageStyleSheet)
, m_origin(origin)
.setStyle(buildObjectForStyle(rule->style()));
// "sourceURL" is present only for regular rules, otherwise "origin" should be used in the frontend.
- if (m_origin == "regular")
+ if (m_origin == TypeBuilder::CSS::CSSRule::Origin::Regular)
result->setSourceURL(finalURL());
if (canBind()) {
InspectorCSSId id(ruleId(rule));
if (!id.isEmpty())
- result->setRuleId(id.asProtocolValue());
+ result->setRuleId(id.asProtocolValue<TypeBuilder::CSS::CSSRuleId>());
}
RefPtr<CSSRuleSourceData> sourceData;
bool InspectorStyleSheet::resourceStyleSheetText(String* result) const
{
- if (m_origin == "user" || m_origin == "user-agent")
+ if (m_origin == TypeBuilder::CSS::CSSRule::Origin::User || m_origin == TypeBuilder::CSS::CSSRule::Origin::User_agent)
return false;
if (!m_pageStyleSheet || !ownerDocument() || !ownerDocument()->frame())
return true;
}
-PassRefPtr<InspectorArray> InspectorStyleSheet::buildArrayForRuleList(CSSRuleList* ruleList)
+PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > InspectorStyleSheet::buildArrayForRuleList(CSSRuleList* ruleList)
{
- RefPtr<InspectorArray> result = InspectorArray::create();
+ RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > result = TypeBuilder::Array<TypeBuilder::CSS::CSSRule>::create();
if (!ruleList)
return result.release();
collectFlatRules(refRuleList, &rules);
for (unsigned i = 0, size = rules.size(); i < size; ++i)
- result->pushObject(buildObjectForRule(rules.at(i)));
+ result->addItem(buildObjectForRule(rules.at(i)));
return result.release();
}
}
}
-PassRefPtr<InspectorStyleSheetForInlineStyle> InspectorStyleSheetForInlineStyle::create(const String& id, PassRefPtr<Element> element, const String& origin, Listener* listener)
+PassRefPtr<InspectorStyleSheetForInlineStyle> InspectorStyleSheetForInlineStyle::create(const String& id, PassRefPtr<Element> element, TypeBuilder::CSS::CSSRule::Origin::Enum origin, Listener* listener)
{
return adoptRef(new InspectorStyleSheetForInlineStyle(id, element, origin, listener));
}
-InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element> element, const String& origin, Listener* listener)
+InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element> element, TypeBuilder::CSS::CSSRule::Origin::Enum origin, Listener* listener)
: InspectorStyleSheet(id, 0, origin, "", listener)
, m_element(element)
, m_ruleSourceData(0)
const String& styleSheetId() const { return m_styleSheetId; }
unsigned ordinal() const { return m_ordinal; }
- PassRefPtr<TypeBuilder::CSS::CSSStyleId> asProtocolValue() const
+ // ID type is either TypeBuilder::CSS::CSSStyleId or TypeBuilder::CSS::CSSRuleId.
+ template<typename ID>
+ PassRefPtr<ID> asProtocolValue() const
{
if (isEmpty())
return 0;
- RefPtr<TypeBuilder::CSS::CSSStyleId> result = TypeBuilder::CSS::CSSStyleId::create()
+ RefPtr<ID> result = ID::create()
.setStyleSheetId(m_styleSheetId)
.setOrdinal(m_ordinal);
return result.release();
};
typedef HashMap<CSSStyleDeclaration*, RefPtr<InspectorStyle> > InspectorStyleMap;
- static PassRefPtr<InspectorStyleSheet> create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener*);
+ static PassRefPtr<InspectorStyleSheet> create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum, const String& documentURL, Listener*);
static String styleSheetURL(CSSStyleSheet* pageStyleSheet);
virtual ~InspectorStyleSheet();
InspectorCSSId styleId(CSSStyleDeclaration* style) const { return ruleOrStyleId(style); }
protected:
- InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener*);
+ InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum, const String& documentURL, Listener*);
- bool canBind() const { return m_origin != "userAgent" && m_origin != "user"; }
+ bool canBind() const { return m_origin != TypeBuilder::CSS::CSSRule::Origin::User_agent && m_origin != TypeBuilder::CSS::CSSRule::Origin::User; }
InspectorCSSId ruleOrStyleId(CSSStyleDeclaration* style) const;
virtual Document* ownerDocument() const;
virtual RefPtr<CSSRuleSourceData> ruleSourceDataFor(CSSStyleDeclaration* style) const;
bool originalStyleSheetText(String* result) const;
bool resourceStyleSheetText(String* result) const;
bool inlineStyleSheetText(String* result) const;
- PassRefPtr<InspectorArray> buildArrayForRuleList(CSSRuleList*);
+ PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > buildArrayForRuleList(CSSRuleList*);
String m_id;
RefPtr<CSSStyleSheet> m_pageStyleSheet;
- String m_origin;
+ TypeBuilder::CSS::CSSRule::Origin::Enum m_origin;
String m_documentURL;
bool m_isRevalidating;
ParsedStyleSheet* m_parsedStyleSheet;
class InspectorStyleSheetForInlineStyle : public InspectorStyleSheet {
public:
- static PassRefPtr<InspectorStyleSheetForInlineStyle> create(const String& id, PassRefPtr<Element>, const String& origin, Listener*);
+ static PassRefPtr<InspectorStyleSheetForInlineStyle> create(const String& id, PassRefPtr<Element>, TypeBuilder::CSS::CSSRule::Origin::Enum, Listener*);
void didModifyElementAttribute();
virtual bool getText(String* result) const;
virtual CSSStyleDeclaration* styleForId(const InspectorCSSId& id) const { ASSERT_UNUSED(id, !id.ordinal()); return inlineStyle(); }
protected:
- InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element>, const String& origin, Listener*);
+ InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element>, TypeBuilder::CSS::CSSRule::Origin::Enum, Listener*);
virtual Document* ownerDocument() const;
virtual RefPtr<CSSRuleSourceData> ruleSourceDataFor(CSSStyleDeclaration* style) const { ASSERT_UNUSED(style, style == inlineStyle()); return m_ruleSourceData; }
git://git.webkit.org / WebKit-https.git / commitdiff