Added support for file URI path wildcards in content settings

chrome/common/render_messages.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Multiply-included file, no traditional include guard.
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 112 matching lines @@
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(ContentSettingsPattern::PatternParts)
   IPC_STRUCT_TRAITS_MEMBER(scheme)
   IPC_STRUCT_TRAITS_MEMBER(is_scheme_wildcard)
   IPC_STRUCT_TRAITS_MEMBER(host)
   IPC_STRUCT_TRAITS_MEMBER(has_domain_wildcard)
   IPC_STRUCT_TRAITS_MEMBER(port)
   IPC_STRUCT_TRAITS_MEMBER(is_port_wildcard)
   IPC_STRUCT_TRAITS_MEMBER(path)
+  IPC_STRUCT_TRAITS_MEMBER(is_path_wildcard)
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(ContentSettingPatternSource)
   IPC_STRUCT_TRAITS_MEMBER(primary_pattern)
   IPC_STRUCT_TRAITS_MEMBER(secondary_pattern)
   IPC_STRUCT_TRAITS_MEMBER(setting)
   IPC_STRUCT_TRAITS_MEMBER(source)
   IPC_STRUCT_TRAITS_MEMBER(incognito)
 IPC_STRUCT_TRAITS_END()
 
@@ skipping 33 matching lines @@
 IPC_STRUCT_TRAITS_END()
 
 //-----------------------------------------------------------------------------
 // RenderView messages
 // These are messages sent from the browser to the renderer process.
 
 // Tells the renderer to set its maximum cache size to the supplied value.
 IPC_MESSAGE_CONTROL3(ChromeViewMsg_SetCacheCapacities,
                      size_t /* min_dead_capacity */,
                      size_t /* max_dead_capacity */,
-                     size_t /* capacity */)
+                     size_t /* capacity */);

[Bernhard Bauer, 2012/01/09 13:23:41]

Don't place semicolons after these macros:
http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/ipc/ipc_message_macro...

In general, don't worry about lint errors in these files; they have a special
format (no header guards, for example).

[Francois, 2012/01/09 14:51:03]

Done.

 
 // Tells the renderer to clear the cache.
 IPC_MESSAGE_CONTROL1(ChromeViewMsg_ClearCache,
-                     bool /* on_navigation */)
+                     bool /* on_navigation */);
 
 // Tells the renderer to dump as much memory as it can, perhaps because we
 // have memory pressure or the renderer is (or will be) paged out.  This
 // should only result in purging objects we can recalculate, e.g. caches or
 // JS garbage, not in purging irreplaceable objects.
-IPC_MESSAGE_CONTROL0(ChromeViewMsg_PurgeMemory)
+IPC_MESSAGE_CONTROL0(ChromeViewMsg_PurgeMemory);
 
 // For WebUI testing, this message stores parameters to do ScriptEvalRequest at
 // a time which is late enough to not be thrown out, and early enough to be
 // before onload events are fired.
 IPC_MESSAGE_ROUTED4(ChromeViewMsg_WebUIJavaScript,
                     string16,  /* frame_xpath */
                     string16,  /* jscript_url */
                     int,  /* ID */
-                    bool  /* If true, result is sent back. */)
+                    bool  /* If true, result is sent back. */);
 
 // Tells the render view to capture a thumbnail image of the page. The
 // render view responds with a ChromeViewHostMsg_Snapshot.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_CaptureSnapshot)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_CaptureSnapshot);
 
 // History system notification that the visited link database has been
 // replaced. It has one SharedMemoryHandle argument consisting of the table
 // handle. This handle is valid in the context of the renderer
 IPC_MESSAGE_CONTROL1(ChromeViewMsg_VisitedLink_NewTable,
-                     base::SharedMemoryHandle)
+                     base::SharedMemoryHandle);
 
 // History system notification that a link has been added and the link
 // coloring state for the given hash must be re-calculated.
-IPC_MESSAGE_CONTROL1(ChromeViewMsg_VisitedLink_Add, std::vector<uint64>)
+IPC_MESSAGE_CONTROL1(ChromeViewMsg_VisitedLink_Add, std::vector<uint64>);
 
 // History system notification that one or more history items have been
 // deleted, which at this point means that all link coloring state must be
 // re-calculated.
-IPC_MESSAGE_CONTROL0(ChromeViewMsg_VisitedLink_Reset)
+IPC_MESSAGE_CONTROL0(ChromeViewMsg_VisitedLink_Reset);
 
 // Set the content setting rules stored by the renderer.
 IPC_MESSAGE_CONTROL1(ChromeViewMsg_SetContentSettingRules,
-                     RendererContentSettingRules /* rules */)
+                     RendererContentSettingRules /* rules */);
 
 // Tells the render view to load all blocked plugins.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_LoadBlockedPlugins)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_LoadBlockedPlugins);
 
 // Asks the renderer to send back stats on the WebCore cache broken down by
 // resource types.
-IPC_MESSAGE_CONTROL0(ChromeViewMsg_GetCacheResourceStats)
+IPC_MESSAGE_CONTROL0(ChromeViewMsg_GetCacheResourceStats);
 
 // Asks the renderer to send back Histograms.
 IPC_MESSAGE_CONTROL1(ChromeViewMsg_GetRendererHistograms,
-                     int /* sequence number of Renderer Histograms. */)
+                     int /* sequence number of Renderer Histograms. */);
 
 // Tells the renderer to create a FieldTrial, and by using a 100% probability
 // for the FieldTrial, forces the FieldTrial to have assigned group name.
 IPC_MESSAGE_CONTROL2(ChromeViewMsg_SetFieldTrialGroup,
                      std::string /* field trial name */,
-                     std::string /* group name that was assigned. */)
+                     std::string /* group name that was assigned. */);
 
 #if defined(USE_TCMALLOC)
 // Asks the renderer to send back tcmalloc stats.
-IPC_MESSAGE_CONTROL0(ChromeViewMsg_GetRendererTcmalloc)
+IPC_MESSAGE_CONTROL0(ChromeViewMsg_GetRendererTcmalloc);
 // Asks the renderer to enable/disable Tcmalloc heap profiling.
 // Note: filename_prefix arg is effectively ignored since the render process
 // will be unable to write files to disk. Instead use WriteTcmallocHeapProfile
 // to write a profile file.
 IPC_MESSAGE_CONTROL2(ChromeViewMsg_SetTcmallocHeapProfiling,
                      bool /* enable profiling */,
-                     std::string /* filename prefix for profiles */)
+                     std::string /* filename prefix for profiles */);
 // Asks the renderer to write the Tcmalloc heap profile to a file.
 IPC_MESSAGE_CONTROL1(ChromeViewMsg_WriteTcmallocHeapProfile,
-                     FilePath::StringType /* filepath */)
+                     FilePath::StringType /* filepath */);
 #endif
 
 // Asks the renderer to send back V8 heap stats.
-IPC_MESSAGE_CONTROL0(ChromeViewMsg_GetV8HeapStats)
+IPC_MESSAGE_CONTROL0(ChromeViewMsg_GetV8HeapStats);
 
 // Posts a message to the renderer.
 IPC_MESSAGE_ROUTED3(ChromeViewMsg_HandleMessageFromExternalHost,
                     std::string /* The message */,
                     std::string /* The origin */,
-                    std::string /* The target*/)
+                    std::string /* The target*/);
 
 IPC_MESSAGE_ROUTED4(ChromeViewMsg_SearchBoxChange,
                     string16 /* value */,
                     bool /* verbatim */,
                     int /* selection_start */,
-                    int /* selection_end */)
+                    int /* selection_end */);
 IPC_MESSAGE_ROUTED2(ChromeViewMsg_SearchBoxSubmit,
                     string16 /* value */,
-                    bool /* verbatim */)
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_SearchBoxCancel)
+                    bool /* verbatim */);
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_SearchBoxCancel);
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_SearchBoxResize,
-                    gfx::Rect /* search_box_bounds */)
+                    gfx::Rect /* search_box_bounds */);
 IPC_MESSAGE_ROUTED4(ChromeViewMsg_DetermineIfPageSupportsInstant,
                     string16 /* value*/,
                     bool /* verbatim */,
                     int /* selection_start */,
-                    int /* selection_end */)
+                    int /* selection_end */);
 
 // Toggles visual muting of the render view area. This is on when a constrained
 // window is showing.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_SetVisuallyDeemphasized,
-                    bool /* deemphazied */)
+                    bool /* deemphazied */);
 
 // Tells the renderer to translate the page contents from one language to
 // another.
 IPC_MESSAGE_ROUTED4(ChromeViewMsg_TranslatePage,
                     int /* page id */,
                     std::string, /* the script injected in the page */
                     std::string, /* BCP 47/RFC 5646 language code the page
                                     is in */
                     std::string /* BCP 47/RFC 5646 language code to translate
-                                   to */)
+                                   to */);
 
 // Tells the renderer to revert the text of translated page to its original
 // contents.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_RevertTranslation,
-                    int /* page id */)
+                    int /* page id */);
 
 // Tells a renderer if it's currently being prerendered.  Must only be set
 // to true before any navigation occurs, and only set to false at most once
 // after that.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_SetIsPrerendering,
-                    bool /* whether the RenderView is prerendering */)
+                    bool /* whether the RenderView is prerendering */);
 
 // Sent on process startup to indicate whether this process is running in
 // incognito mode.
 IPC_MESSAGE_CONTROL1(ChromeViewMsg_SetIsIncognitoProcess,
-                     bool /* is_incognito_processs */)
+                     bool /* is_incognito_processs */);
 
 // Sent in response to ViewHostMsg_DidBlockDisplayingInsecureContent.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_SetAllowDisplayingInsecureContent,
-                    bool /* allowed */)
+                    bool /* allowed */);
 
 // Sent in response to ViewHostMsg_DidBlockRunningInsecureContent.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_SetAllowRunningInsecureContent,
-                    bool /* allowed */)
+                    bool /* allowed */);
 
 // Tells renderer to always enforce mixed content blocking for this host.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_AddStrictSecurityHost,
-                    std::string /* host */)
+                    std::string /* host */);
 
 // Sent when the profile changes the kSafeBrowsingEnabled preference.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_SetClientSidePhishingDetection,
-                    bool /* enable_phishing_detection */)
+                    bool /* enable_phishing_detection */);
 
 // This message asks frame sniffer start.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_StartFrameSniffer,
-                    string16 /* frame-name */)
+                    string16 /* frame-name */);
 
 // JavaScript related messages -----------------------------------------------
 
 // Notify the JavaScript engine in the render to change its parameters
 // while performing stress testing.
 IPC_MESSAGE_ROUTED2(ChromeViewMsg_JavaScriptStressTestControl,
                     int /* cmd */,
-                    int /* param */)
+                    int /* param */);
 
 // Asks the renderer to send back FPS.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_GetFPS)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_GetFPS);
 
 // Tells the view it is displaying an interstitial page.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_SetAsInterstitial)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_SetAsInterstitial);
 
 //-----------------------------------------------------------------------------
 // TabContents messages
 // These are messages sent from the renderer to the browser process.
 
 // Provides the contents for the given page that was loaded recently.
 IPC_MESSAGE_ROUTED3(ChromeViewHostMsg_PageContents,
                     GURL         /* URL of the page */,
                     int32        /* page id */,
-                    string16     /* page contents */)
+                    string16     /* page contents */);
 
 // Notification that the language for the tab has been determined.
 IPC_MESSAGE_ROUTED2(ChromeViewHostMsg_TranslateLanguageDetermined,
                     std::string  /* page ISO639_1 language code */,
-                    bool         /* whether the page can be translated */)
+                    bool         /* whether the page can be translated */);
 
 IPC_MESSAGE_CONTROL1(ChromeViewHostMsg_UpdatedCacheStats,
-                     WebKit::WebCache::UsageStats /* stats */)
+                     WebKit::WebCache::UsageStats /* stats */);
 
 // Tells the browser that content in the current page was blocked due to the
 // user's content settings.
 IPC_MESSAGE_ROUTED2(ChromeViewHostMsg_ContentBlocked,
                     ContentSettingsType, /* type of blocked content */
-                    std::string /* resource identifier */)
+                    std::string /* resource identifier */);
 
 // Sent by the renderer process to check whether access to web databases is
 // granted by content settings.
 IPC_SYNC_MESSAGE_CONTROL5_1(ChromeViewHostMsg_AllowDatabase,
                             int /* render_view_id */,
                             GURL /* origin_url */,
                             GURL /* top origin url */,
                             string16 /* database name */,
                             string16 /* database display name */,
-                            bool /* allowed */)
+                            bool /* allowed */);
 
 // Sent by the renderer process to check whether access to DOM Storage is
 // granted by content settings.
 IPC_SYNC_MESSAGE_CONTROL4_1(ChromeViewHostMsg_AllowDOMStorage,
                             int /* render_view_id */,
                             GURL /* origin_url */,
                             GURL /* top origin url */,
                             bool /* if true local storage, otherwise session */,
-                            bool /* allowed */)
+                            bool /* allowed */);
 
 // Sent by the renderer process to check whether access to FileSystem is
 // granted by content settings.
 IPC_SYNC_MESSAGE_CONTROL3_1(ChromeViewHostMsg_AllowFileSystem,
                             int /* render_view_id */,
                             GURL /* origin_url */,
                             GURL /* top origin url */,
-                            bool /* allowed */)
+                            bool /* allowed */);
 
 // Sent by the renderer process to check whether access to Indexed DBis
 // granted by content settings.
 IPC_SYNC_MESSAGE_CONTROL4_1(ChromeViewHostMsg_AllowIndexedDB,
                             int /* render_view_id */,
                             GURL /* origin_url */,
                             GURL /* top origin url */,
                             string16 /* database name */,
-                            bool /* allowed */)
+                            bool /* allowed */);
 
 // Return information about a plugin for the given URL and MIME type.
 // In contrast to ViewHostMsg_GetPluginInfo in content/, this IPC call knows
 // about specific reasons why a plug-in can't be used, for example because it's
 // disabled.
 IPC_SYNC_MESSAGE_CONTROL4_3(ChromeViewHostMsg_GetPluginInfo,
                             int /* render_view_id */,
                             GURL /* url */,
                             GURL /* top origin url */,
                             std::string /* mime_type */,
                             ChromeViewHostMsg_GetPluginInfo_Status /* status */,
                             webkit::WebPluginInfo /* plugin */,
-                            std::string /* actual_mime_type */)
+                            std::string /* actual_mime_type */);
 
 // Tells the browser to search for a plug-in that can handle the given MIME
 // type. The result will be sent asynchronously to the routing ID
 // |placeholder_id|.
 IPC_MESSAGE_ROUTED2(ChromeViewHostMsg_FindMissingPlugin,
                     int /* placeholder_id */,
-                    std::string /* mime_type */)
+                    std::string /* mime_type */);
 
 // Notifies a missing plug-in placeholder that a plug-in with name |plugin_name|
 // has been found.
 IPC_MESSAGE_ROUTED1(ChromeViewMsg_FoundMissingPlugin,
-                    string16 /* plugin_name */)
+                    string16 /* plugin_name */);
 
 // Notifies a missing plug-in placeholder that no plug-in has been found.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_DidNotFindMissingPlugin)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_DidNotFindMissingPlugin);
 
 // Notifies a missing plug-in placeholder that we have started downloading
 // the plug-in.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_StartedDownloadingPlugin)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_StartedDownloadingPlugin);
 
 // Notifies a missing plug-in placeholder that we have finished downloading
 // the plug-in.
-IPC_MESSAGE_ROUTED0(ChromeViewMsg_FinishedDownloadingPlugin)
+IPC_MESSAGE_ROUTED0(ChromeViewMsg_FinishedDownloadingPlugin);
 
 // Specifies the URL as the first parameter (a wstring) and thumbnail as
 // binary data as the second parameter.
 IPC_MESSAGE_ROUTED3(ChromeViewHostMsg_Thumbnail,
                     GURL /* url */,
                     ThumbnailScore /* score */,
-                    SkBitmap /* bitmap */)
+                    SkBitmap /* bitmap */);
 
 // Send a snapshot of the tab contents to the render host.
 IPC_MESSAGE_ROUTED1(ChromeViewHostMsg_Snapshot,
-                    SkBitmap /* bitmap */)
+                    SkBitmap /* bitmap */);
 
 // Following message is used to communicate the values received by the
 // callback binding the JS to Cpp.
 // An instance of browser that has an automation host listening to it can
 // have a javascript send a native value (string, number, boolean) to the
 // listener in Cpp. (DomAutomationController)
 IPC_MESSAGE_ROUTED2(ChromeViewHostMsg_DomOperationResponse,
                     std::string  /* json_string */,
-                    int  /* automation_id */)
+                    int  /* automation_id */);
 
 // A message for an external host.
 IPC_MESSAGE_ROUTED3(ChromeViewHostMsg_ForwardMessageToExternalHost,
                     std::string  /* message */,
                     std::string  /* origin */,
-                    std::string  /* target */)
+                    std::string  /* target */);
 
 // A renderer sends this to the browser process when it wants to start
 // a new instance of the Native Client process. The browser will launch
 // the process and return a handle to an IMC channel.
 IPC_SYNC_MESSAGE_CONTROL2_3(ChromeViewHostMsg_LaunchNaCl,
                             std::wstring /* url for the NaCl module */,
                             int /* socket count */,
                             std::vector<nacl::FileDescriptor>
                                 /* imc channel handles */,
                             base::ProcessHandle /* NaCl process handle */,
-                            base::ProcessId /* NaCl process id */)
+                            base::ProcessId /* NaCl process id */);
 
 // Notification that the page has an OpenSearch description document
 // associated with it.
 IPC_MESSAGE_ROUTED3(ChromeViewHostMsg_PageHasOSDD,
                     int32 /* page_id */,
                     GURL /* url of OS description document */,
-                    search_provider::OSDDType)
+                    search_provider::OSDDType);
 
 // Find out if the given url's security origin is installed as a search
 // provider.
 IPC_SYNC_MESSAGE_ROUTED2_1(ChromeViewHostMsg_GetSearchProviderInstallState,
                            GURL /* page url */,
                            GURL /* inquiry url */,
-                           search_provider::InstallState /* install */)
+                           search_provider::InstallState /* install */);
 
 // Send back histograms as vector of pickled-histogram strings.
 IPC_MESSAGE_CONTROL2(ChromeViewHostMsg_RendererHistograms,
                      int, /* sequence number of Renderer Histograms. */
-                     std::vector<std::string>)
+                     std::vector<std::string>);
 
 #if defined USE_TCMALLOC
 // Send back tcmalloc stats output.
 IPC_MESSAGE_CONTROL1(ChromeViewHostMsg_RendererTcmalloc,
-                     std::string  /* tcmalloc debug output */)
+                     std::string  /* tcmalloc debug output */);
 // Send back tcmalloc profile to write to a file.
 IPC_MESSAGE_CONTROL2(ChromeViewHostMsg_WriteTcmallocHeapProfile_ACK,
                      FilePath::StringType  /* filepath */,
-                     std::string  /* heap profile */)
+                     std::string  /* heap profile */);
 #endif
 
 // Sends back stats about the V8 heap.
 IPC_MESSAGE_CONTROL2(ChromeViewHostMsg_V8HeapStats,
                      int /* size of heap (allocated from the OS) */,
-                     int /* bytes in use */)
+                     int /* bytes in use */);
 
 // Request for a DNS prefetch of the names in the array.
 // NameList is typedef'ed std::vector<std::string>
 IPC_MESSAGE_CONTROL1(ChromeViewHostMsg_DnsPrefetch,
-                     std::vector<std::string> /* hostnames */)
+                     std::vector<std::string> /* hostnames */);
 
 // Notifies when a plugin couldn't be loaded because it's outdated.
 IPC_MESSAGE_ROUTED2(ChromeViewHostMsg_BlockedOutdatedPlugin,
                     string16, /* name */
-                    GURL      /* update_url */)
+                    GURL      /* update_url */);
 
 // Provide the browser process with information about the WebCore resource
 // cache and current renderer framerate.
 IPC_MESSAGE_CONTROL1(ChromeViewHostMsg_ResourceTypeStats,
-                     WebKit::WebCache::ResourceTypeStats)
+                     WebKit::WebCache::ResourceTypeStats);
 
 
 // Notifies the browser of the language (ISO 639_1 code language, such as fr,
 // en, zh...) of the current page.
 IPC_MESSAGE_ROUTED1(ChromeViewHostMsg_PageLanguageDetermined,
-                    std::string /* the language */)
+                    std::string /* the language */);
 
 // Notifies the browser that a page has been translated.
 IPC_MESSAGE_ROUTED4(ChromeViewHostMsg_PageTranslated,
                     int,                  /* page id */
                     std::string           /* the original language */,
                     std::string           /* the translated language */,
-                    TranslateErrors::Type /* the error type if available */)
+                    TranslateErrors::Type /* the error type if available */);
 
 // Message sent from the renderer to the browser to notify it of events which
 // may lead to the cancellation of a prerender. The message is sent only when
 // the renderer is prerendering.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_MaybeCancelPrerenderForHTML5Media)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_MaybeCancelPrerenderForHTML5Media);
 
 // Message sent from the renderer to the browser to notify it of a
 // window.print() call which should cancel the prerender. The message is sent
 // only when the renderer is prerendering.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_CancelPrerenderForPrinting)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_CancelPrerenderForPrinting);
 
 // Sent by the renderer to check if a URL has permission to trigger a clipboard
 // read/write operation from the DOM.
 IPC_SYNC_MESSAGE_ROUTED1_1(ChromeViewHostMsg_CanTriggerClipboardRead,
                            GURL /* origin */,
-                           bool /* allowed */)
+                           bool /* allowed */);
 IPC_SYNC_MESSAGE_ROUTED1_1(ChromeViewHostMsg_CanTriggerClipboardWrite,
                            GURL /* origin */,
-                           bool /* allowed */)
+                           bool /* allowed */);
 
 // Sent when the renderer was prevented from displaying insecure content in
 // a secure page by a security policy.  The page may appear incomplete.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_DidBlockDisplayingInsecureContent)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_DidBlockDisplayingInsecureContent);
 
 // Sent when the renderer was prevented from running insecure content in
 // a secure origin by a security policy.  The page may appear incomplete.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_DidBlockRunningInsecureContent)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_DidBlockRunningInsecureContent);
 
 // Message sent from renderer to the browser when the element that is focused
 // and currently accepts keyboard input inside the webpage has been touched.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_FocusedEditableNodeTouched)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_FocusedEditableNodeTouched);
 
 // Suggest results -----------------------------------------------------------
 
 IPC_MESSAGE_ROUTED3(ChromeViewHostMsg_SetSuggestions,
                     int32 /* page_id */,
                     std::vector<std::string> /* suggestions */,
-                    InstantCompleteBehavior)
+                    InstantCompleteBehavior);
 
 IPC_MESSAGE_ROUTED2(ChromeViewHostMsg_InstantSupportDetermined,
                     int32 /* page_id */,
-                    bool  /* result */)
+                    bool  /* result */);
 
 // The currently displayed PDF has an unsupported feature.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_PDFHasUnsupportedFeature)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_PDFHasUnsupportedFeature);
 
 // This message indicates the error appeared in the frame.
 IPC_MESSAGE_ROUTED1(ChromeViewHostMsg_FrameLoadingError,
-                    int /* error */)
+                    int /* error */);
 
 // This message indicates the monitored frame loading had completed.
-IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_FrameLoadingCompleted)
+IPC_MESSAGE_ROUTED0(ChromeViewHostMsg_FrameLoadingCompleted);
 
 // The following messages are used to set and get cookies for ChromeFrame
 // processes.
 // Used to set a cookie. The cookie is set asynchronously, but will be
 // available to a subsequent ChromeViewHostMsg_GetCookies request.
 IPC_MESSAGE_ROUTED3(ChromeViewHostMsg_SetCookie,
                     GURL /* url */,
                     GURL /* first_party_for_cookies */,
-                    std::string /* cookie */)
+                    std::string /* cookie */);
 
 // Used to get cookies for the given URL. This may block waiting for a
 // previous SetCookie message to be processed.
 IPC_SYNC_MESSAGE_ROUTED2_1(ChromeViewHostMsg_GetCookies,
                            GURL /* url */,
                            GURL /* first_party_for_cookies */,
-                           std::string /* cookies */)
+                           std::string /* cookies */);
 
 // Provide the browser process with current renderer framerate.
 IPC_MESSAGE_CONTROL2(ChromeViewHostMsg_FPS,
                      int /* routing id */,
-                     float /* frames per second */)
+                     float /* frames per second */);