Fix trailing whitespace in .cpp, .h, and .idl files (ex. Source/core)

Source/web/WebPageSerializer.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 81 matching lines @@
     else if (element->hasTagName(HTMLNames::embedTag))
         attributeName = &HTMLNames::srcAttr;
 
     if (!attributeName)
         return KURL();
 
     String value = element->getAttribute(*attributeName);
     // Ignore javascript content.
     if (value.isEmpty() || value.stripWhiteSpace().startsWith("javascript:", false))
         return KURL();
-  
+
     return element->document()->completeURL(value);
 }
 
 void retrieveResourcesForElement(Element* element,
                                  Vector<Frame*>* visitedFrames,
                                  Vector<Frame*>* framesToVisit,
                                  Vector<KURL>* frameURLs,
                                  Vector<KURL>* resourceURLs)
 {
     // If the node is a frame, we'll process it later in retrieveResourcesForFrame.
@@ skipping 44 matching lines @@
     }
     if (!isValidScheme)
         return;
 
     // If we have already seen that frame, ignore it.
     if (visitedFrames->contains(frame))
         return;
     visitedFrames->append(frame);
     if (!frameURLs->contains(frameURL))
         frameURLs->append(frameURL);
-  
+
     // Now get the resources associated with each node of the document.
     RefPtr<HTMLCollection> allNodes = frame->document()->all();
     for (unsigned i = 0; i < allNodes->length(); ++i) {
         Node* node = allNodes->item(i);
         // We are only interested in HTML resources.
         if (!node->isElementNode())
             continue;
         retrieveResourcesForElement(toElement(node),
                                     visitedFrames, framesToVisit,
                                     frameURLs, resourceURLs);
@@ skipping 13 matching lines @@
     Vector<Resource> result;
     for (Vector<SerializedResource>::const_iterator iter = resources.begin(); iter != resources.end(); ++iter) {
         Resource resource;
         resource.url = iter->url;
         resource.mimeType = iter->mimeType.ascii();
         // FIXME: we are copying all the resource data here. Idealy we would have a WebSharedData().
         resource.data = WebCString(iter->data->data(), iter->data->size());
         result.append(resource);
     }
 
-    *resourcesParam = result;         
+    *resourcesParam = result;
 }
 
 static PassRefPtr<SharedBuffer> serializePageToMHTML(Page* page, MHTMLArchive::EncodingPolicy encodingPolicy)
 {
     Vector<SerializedResource> resources;
     PageSerializer serializer(&resources);
     serializer.serialize(page);
     Document* document = page->mainFrame()->document();
     return MHTMLArchive::generateMHTMLData(resources, encodingPolicy, document->title(), document->suggestedMIMEType());
 }
@@ skipping 29 matching lines @@
                                              WebVector<WebURL>* resourceURLs,
                                              WebVector<WebURL>* frameURLs) {
     WebFrameImpl* mainFrame = static_cast<WebFrameImpl*>(view->mainFrame());
     if (!mainFrame)
         return false;
 
     Vector<Frame*> framesToVisit;
     Vector<Frame*> visitedFrames;
     Vector<KURL> frameKURLs;
     Vector<KURL> resourceKURLs;
-    
+
     // Let's retrieve the resources from every frame in this page.
     framesToVisit.append(mainFrame->frame());
     while (!framesToVisit.isEmpty()) {
         Frame* frame = framesToVisit[0];
         framesToVisit.remove(0);
         retrieveResourcesForFrame(frame, supportedSchemes,
                                   &visitedFrames, &framesToVisit,
                                   &frameKURLs, &resourceKURLs);
     }
 
     // Converts the results to WebURLs.
     WebVector<WebURL> resultResourceURLs(resourceKURLs.size());
     for (size_t i = 0; i < resourceKURLs.size(); ++i) {
         resultResourceURLs[i] = resourceKURLs[i];
         // A frame's src can point to the same URL as another resource, keep the
         // resource URL only in such cases.
         size_t index = frameKURLs.find(resourceKURLs[i]);
         if (index != notFound)
             frameKURLs.remove(index);
     }
     *resourceURLs = resultResourceURLs;
     WebVector<WebURL> resultFrameURLs(frameKURLs.size());
     for (size_t i = 0; i < frameKURLs.size(); ++i)
         resultFrameURLs[i] = frameKURLs[i];
     *frameURLs = resultFrameURLs;
-    
+
     return true;
 }
 
 WebString WebPageSerializer::generateMetaCharsetDeclaration(const WebString& charset)
 {
     String charsetString = "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=" + static_cast<const String&>(charset) + "\">";
     return charsetString;
 }
 
 WebString WebPageSerializer::generateMarkOfTheWebDeclaration(const WebURL& url)
 {
     return String::format("\n<!-- saved from url=(%04d)%s -->\n",
                           static_cast<int>(url.spec().length()),
                           url.spec().data());
 }
 
 WebString WebPageSerializer::generateBaseTagDeclaration(const WebString& baseTarget)
 {
     if (baseTarget.isEmpty())
         return String(ASCIILiteral("<base href=\".\">"));
     String baseString = "<base href=\".\" target=\"" + static_cast<const String&>(baseTarget) + "\">";
     return baseString;
 }
 
 } // namespace WebKit