diff --git a/public/.gitignore b/public/.gitignore
new file mode 100644
index 0000000..900b472
--- /dev/null
+++ b/public/.gitignore
@@ -0,0 +1,5 @@
+# Generated XCode projects.
+all.xcodeproj
+blink.xcodeproj
+blink_skia_config.xcodeproj
+blink_test_runner.xcodeproj
diff --git a/public/README b/public/README
index 8c1c326..0da44c2 100644
--- a/public/README
+++ b/public/README
@@ -54,12 +54,12 @@
 
 The API uses some internal types (e.g., WebCore::Node). Typically, these types
 are forward declared and are opaque to consumers of the API. In other cases,
-the full definitions are available behind the WEBKIT_IMPLEMENTATION
+the full definitions are available behind the BLINK_IMPLEMENTATION
 preprocessor macro. In both cases, we continue to regard these internal types
 as implementation details of Blink, and consumers of the API should not rely
 upon these types.
 
-Similarly, the API uses STL types outside of the WEBKIT_IMPLEMENTATION
+Similarly, the API uses STL types outside of the BLINK_IMPLEMENTATION
 preprocessor macro, which is for the convenience of the consumer.
 
 Contact Information
diff --git a/public/all.gyp b/public/all.gyp
index 0d01f1a..f3e68c4 100644
--- a/public/all.gyp
+++ b/public/all.gyp
@@ -37,6 +37,7 @@
             'type': 'none',
             'dependencies': [
                 '../Source/testing/testing.gyp:TestRunner',
+                '../Source/platform/blink_platform_tests.gyp:blink_platform_unittests',
                 '../Source/web/web_tests.gyp:webkit_unit_tests',
                 '../Source/weborigin/weborigin_tests.gyp:weborigin_unittests',
                 '../Source/wtf/wtf_tests.gyp:wtf_unittests',
diff --git a/public/platform/Platform.h b/public/platform/Platform.h
index b387aad..b67585a 100644
--- a/public/platform/Platform.h
+++ b/public/platform/Platform.h
@@ -106,9 +106,9 @@
     typedef int FileHandle;
 #endif
 
-    WEBKIT_EXPORT static void initialize(Platform*);
-    WEBKIT_EXPORT static void shutdown();
-    WEBKIT_EXPORT static Platform* current();
+    BLINK_EXPORT static void initialize(Platform*);
+    BLINK_EXPORT static void shutdown();
+    BLINK_EXPORT static Platform* current();
 
     // May return null.
     virtual WebCookieJar* cookieJar() { return 0; }
@@ -284,6 +284,12 @@
     // A wrapper for tcmalloc's GetHeapProfile()
     virtual WebString getHeapProfile() { return WebString(); }
 
+    static const size_t noDecodedImageByteLimit = static_cast<size_t>(-1);
+
+    // Returns the maximum amount of memory a decoded image should be allowed.
+    // See comments on ImageDecoder::m_maxDecodedBytes.
+    virtual size_t maxDecodedImageBytes() { return noDecodedImageByteLimit; }
+
 
     // Message Ports -------------------------------------------------------
 
diff --git a/public/platform/WebAnimation.h b/public/platform/WebAnimation.h
index 5ddd30d..0702a51 100644
--- a/public/platform/WebAnimation.h
+++ b/public/platform/WebAnimation.h
@@ -29,7 +29,7 @@
 #include "WebNonCopyable.h"
 #include "WebPrivateOwnPtr.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/Forward.h"
 #endif
 
diff --git a/public/platform/WebArrayBuffer.h b/public/platform/WebArrayBuffer.h
index aee4b0b..961833a 100644
--- a/public/platform/WebArrayBuffer.h
+++ b/public/platform/WebArrayBuffer.h
@@ -55,19 +55,19 @@
         return *this;
     }
 
-    WEBKIT_EXPORT static WebArrayBuffer create(unsigned numElements, unsigned elementByteSize);
+    BLINK_EXPORT static WebArrayBuffer create(unsigned numElements, unsigned elementByteSize);
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebArrayBuffer&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebArrayBuffer&);
 
     bool isNull() const { return m_private.isNull(); }
-    WEBKIT_EXPORT void* data() const;
-    WEBKIT_EXPORT unsigned byteLength() const;
+    BLINK_EXPORT void* data() const;
+    BLINK_EXPORT unsigned byteLength() const;
 
-    WEBKIT_EXPORT v8::Handle<v8::Value> toV8Value();
-    WEBKIT_EXPORT static WebArrayBuffer* createFromV8Value(v8::Handle<v8::Value>);
+    BLINK_EXPORT v8::Handle<v8::Value> toV8Value();
+    BLINK_EXPORT static WebArrayBuffer* createFromV8Value(v8::Handle<v8::Value>);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebArrayBuffer(const WTF::PassRefPtr<WTF::ArrayBuffer>&);
     WebArrayBuffer& operator=(const PassRefPtr<WTF::ArrayBuffer>&);
     operator WTF::PassRefPtr<WTF::ArrayBuffer>() const;
diff --git a/public/platform/WebAudioBus.h b/public/platform/WebAudioBus.h
index 7c42fc5..4d33407 100644
--- a/public/platform/WebAudioBus.h
+++ b/public/platform/WebAudioBus.h
@@ -29,7 +29,7 @@
 
 namespace WebCore { class AudioBus; }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
 
@@ -47,22 +47,22 @@
     ~WebAudioBus() { reset(); }
 
     // initialize() allocates memory of the given length for the given number of channels.
-    WEBKIT_EXPORT void initialize(unsigned numberOfChannels, size_t length, double sampleRate);
+    BLINK_EXPORT void initialize(unsigned numberOfChannels, size_t length, double sampleRate);
 
     // resizeSmaller() can only be called after initialize() with a new length <= the initialization length.
     // The data stored in the bus will remain undisturbed.
-    WEBKIT_EXPORT void resizeSmaller(size_t newLength);
+    BLINK_EXPORT void resizeSmaller(size_t newLength);
 
     // reset() releases the memory allocated from initialize().
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT unsigned numberOfChannels() const;
-    WEBKIT_EXPORT size_t length() const;
-    WEBKIT_EXPORT double sampleRate() const;
+    BLINK_EXPORT unsigned numberOfChannels() const;
+    BLINK_EXPORT size_t length() const;
+    BLINK_EXPORT double sampleRate() const;
 
-    WEBKIT_EXPORT float* channelData(unsigned channelIndex);
+    BLINK_EXPORT float* channelData(unsigned channelIndex);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WTF::PassRefPtr<WebCore::AudioBus> release();
 #endif
 
diff --git a/public/platform/WebBlobData.h b/public/platform/WebBlobData.h
index 54a74e9..96c5fda 100644
--- a/public/platform/WebBlobData.h
+++ b/public/platform/WebBlobData.h
@@ -35,7 +35,7 @@
 #include "WebThreadSafeData.h"
 #include "WebURL.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class BlobData; }
 namespace WTF { template <typename T> class PassOwnPtr; }
 #endif
@@ -68,30 +68,30 @@
 
     WebBlobData() : m_private(0) { }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
 
     bool isNull() const { return !m_private; }
 
     // Returns the number of items.
-    WEBKIT_EXPORT size_t itemCount() const;
+    BLINK_EXPORT size_t itemCount() const;
 
     // Retrieves the values of the item at the given index. Returns false if
     // index is out of bounds.
-    WEBKIT_EXPORT bool itemAt(size_t index, Item& result) const;
+    BLINK_EXPORT bool itemAt(size_t index, Item& result) const;
 
-    WEBKIT_EXPORT WebString contentType() const;
+    BLINK_EXPORT WebString contentType() const;
 
-    WEBKIT_EXPORT WebString contentDisposition() const;
+    BLINK_EXPORT WebString contentDisposition() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebBlobData(const WTF::PassOwnPtr<WebCore::BlobData>&);
     WebBlobData& operator=(const WTF::PassOwnPtr<WebCore::BlobData>&);
     operator WTF::PassOwnPtr<WebCore::BlobData>();
 #endif
 
 private:
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     void assign(const WTF::PassOwnPtr<WebCore::BlobData>&);
 #endif
     WebBlobDataPrivate* m_private;
diff --git a/public/platform/WebCommon.h b/public/platform/WebCommon.h
index 832072e..27fd422 100644
--- a/public/platform/WebCommon.h
+++ b/public/platform/WebCommon.h
@@ -31,22 +31,22 @@
 #ifndef WebCommon_h
 #define WebCommon_h
 
-#if !defined(WEBKIT_IMPLEMENTATION)
-#define WEBKIT_IMPLEMENTATION 0
+#if !defined(BLINK_IMPLEMENTATION)
+#define BLINK_IMPLEMENTATION 0
 #endif
 
 #if defined(COMPONENT_BUILD)
 #if defined(WIN32)
-#if WEBKIT_IMPLEMENTATION
-#define WEBKIT_EXPORT __declspec(dllexport)
-#else // WEBKIT_IMPLEMENTATION
-#define WEBKIT_EXPORT __declspec(dllimport)
+#if BLINK_IMPLEMENTATION
+#define BLINK_EXPORT __declspec(dllexport)
+#else // BLINK_IMPLEMENTATION
+#define BLINK_EXPORT __declspec(dllimport)
 #endif
 #else // defined(WIN32)
-#define WEBKIT_EXPORT __attribute__((visibility("default")))
+#define BLINK_EXPORT __attribute__((visibility("default")))
 #endif
 #else // defined(COMPONENT_BUILD)
-#define WEBKIT_EXPORT
+#define BLINK_EXPORT
 #endif
 
 #if !defined(BLINK_COMMON_IMPLEMENTATION)
diff --git a/public/platform/WebCrypto.h b/public/platform/WebCrypto.h
index 5cb482a..92bbaa0 100644
--- a/public/platform/WebCrypto.h
+++ b/public/platform/WebCrypto.h
@@ -37,7 +37,7 @@
 
 namespace WebCore { class CryptoResult; }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
 
@@ -63,20 +63,20 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void completeWithError();
-    WEBKIT_EXPORT void completeWithBuffer(const WebArrayBuffer&);
-    WEBKIT_EXPORT void completeWithBuffer(const void*, unsigned);
-    WEBKIT_EXPORT void completeWithBoolean(bool);
-    WEBKIT_EXPORT void completeWithKey(const WebCryptoKey&);
-    WEBKIT_EXPORT void completeWithKeyPair(const WebCryptoKey& publicKey, const WebCryptoKey& privateKey);
+    BLINK_EXPORT void completeWithError();
+    BLINK_EXPORT void completeWithBuffer(const WebArrayBuffer&);
+    BLINK_EXPORT void completeWithBuffer(const void*, unsigned);
+    BLINK_EXPORT void completeWithBoolean(bool);
+    BLINK_EXPORT void completeWithKey(const WebCryptoKey&);
+    BLINK_EXPORT void completeWithKeyPair(const WebCryptoKey& publicKey, const WebCryptoKey& privateKey);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebCryptoResult(const WTF::PassRefPtr<WebCore::CryptoResult>&);
 #endif
 
 private:
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebCryptoResult&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebCryptoResult&);
 
     WebPrivatePtr<WebCore::CryptoResult> m_impl;
 };
diff --git a/public/platform/WebCryptoAlgorithm.h b/public/platform/WebCryptoAlgorithm.h
index 0aed196..f52465b 100644
--- a/public/platform/WebCryptoAlgorithm.h
+++ b/public/platform/WebCryptoAlgorithm.h
@@ -34,7 +34,7 @@
 #include "WebCommon.h"
 #include "WebPrivatePtr.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/PassOwnPtr.h"
 #endif
 
@@ -50,7 +50,7 @@
     WebCryptoAlgorithmIdSha256,
     WebCryptoAlgorithmIdSha384,
     WebCryptoAlgorithmIdSha512,
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     NumberOfWebCryptoAlgorithmId,
 #endif
 };
@@ -81,12 +81,12 @@
 //   * Copiable (cheaply)
 class WebCryptoAlgorithm {
 public:
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebCryptoAlgorithm() { }
     WebCryptoAlgorithm(WebCryptoAlgorithmId, PassOwnPtr<WebCryptoAlgorithmParams>);
 #endif
 
-    WEBKIT_EXPORT static WebCryptoAlgorithm adoptParamsAndCreate(WebCryptoAlgorithmId, WebCryptoAlgorithmParams*);
+    BLINK_EXPORT static WebCryptoAlgorithm adoptParamsAndCreate(WebCryptoAlgorithmId, WebCryptoAlgorithmParams*);
 
     ~WebCryptoAlgorithm() { reset(); }
 
@@ -97,22 +97,22 @@
         return *this;
     }
 
-    WEBKIT_EXPORT WebCryptoAlgorithmId id() const;
+    BLINK_EXPORT WebCryptoAlgorithmId id() const;
 
-    WEBKIT_EXPORT WebCryptoAlgorithmParamsType paramsType() const;
+    BLINK_EXPORT WebCryptoAlgorithmParamsType paramsType() const;
 
     // Retrieves the type-specific parameters. The algorithm contains at most 1
     // type of parameters. Retrieving an invalid parameter will return 0.
-    WEBKIT_EXPORT const WebCryptoAesCbcParams* aesCbcParams() const;
-    WEBKIT_EXPORT const WebCryptoAesKeyGenParams* aesKeyGenParams() const;
-    WEBKIT_EXPORT const WebCryptoHmacParams* hmacParams() const;
-    WEBKIT_EXPORT const WebCryptoHmacKeyParams* hmacKeyParams() const;
-    WEBKIT_EXPORT const WebCryptoRsaSsaParams* rsaSsaParams() const;
-    WEBKIT_EXPORT const WebCryptoRsaKeyGenParams* rsaKeyGenParams() const;
+    BLINK_EXPORT const WebCryptoAesCbcParams* aesCbcParams() const;
+    BLINK_EXPORT const WebCryptoAesKeyGenParams* aesKeyGenParams() const;
+    BLINK_EXPORT const WebCryptoHmacParams* hmacParams() const;
+    BLINK_EXPORT const WebCryptoHmacKeyParams* hmacKeyParams() const;
+    BLINK_EXPORT const WebCryptoRsaSsaParams* rsaSsaParams() const;
+    BLINK_EXPORT const WebCryptoRsaKeyGenParams* rsaKeyGenParams() const;
 
 private:
-    WEBKIT_EXPORT void assign(const WebCryptoAlgorithm& other);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebCryptoAlgorithm& other);
+    BLINK_EXPORT void reset();
 
     WebPrivatePtr<WebCryptoAlgorithmPrivate> m_private;
 };
diff --git a/public/platform/WebCryptoAlgorithmParams.h b/public/platform/WebCryptoAlgorithmParams.h
index 712e12f..b321bec 100644
--- a/public/platform/WebCryptoAlgorithmParams.h
+++ b/public/platform/WebCryptoAlgorithmParams.h
@@ -61,7 +61,7 @@
 
 class WebCryptoAesCbcParams : public WebCryptoAlgorithmParams {
 public:
-    WebCryptoAesCbcParams(unsigned char* iv, unsigned ivSize)
+    WebCryptoAesCbcParams(const unsigned char* iv, unsigned ivSize)
         : WebCryptoAlgorithmParams(WebCryptoAlgorithmParamsTypeAesCbcParams)
         , m_iv(iv, ivSize)
     {
diff --git a/public/platform/WebCryptoKey.h b/public/platform/WebCryptoKey.h
index 7441b2c..7ac11e2 100644
--- a/public/platform/WebCryptoKey.h
+++ b/public/platform/WebCryptoKey.h
@@ -50,7 +50,7 @@
     WebCryptoKeyUsageDeriveKey = 1 << 4,
     WebCryptoKeyUsageWrapKey = 1 << 5,
     WebCryptoKeyUsageUnwrapKey = 1 << 6,
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     EndOfWebCryptoKeyUsage,
 #endif
 };
@@ -103,22 +103,22 @@
     // https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html#key-interface-members
     //
     // Note that the caller is passing ownership of the WebCryptoKeyHandle*.
-    WEBKIT_EXPORT static WebCryptoKey create(WebCryptoKeyHandle*, WebCryptoKeyType, bool extractable, const WebCryptoAlgorithm&, WebCryptoKeyUsageMask);
+    BLINK_EXPORT static WebCryptoKey create(WebCryptoKeyHandle*, WebCryptoKeyType, bool extractable, const WebCryptoAlgorithm&, WebCryptoKeyUsageMask);
 
     // Returns the opaque key handle that was set by the embedder.
     //   * Safe to downcast to known type (since embedder creates all the keys)
     //   * Returned pointer's lifetime is bound to |this|
-    WEBKIT_EXPORT WebCryptoKeyHandle* handle() const;
+    BLINK_EXPORT WebCryptoKeyHandle* handle() const;
 
-    WEBKIT_EXPORT WebCryptoKeyType type() const;
-    WEBKIT_EXPORT bool extractable() const;
-    WEBKIT_EXPORT const WebCryptoAlgorithm& algorithm() const;
-    WEBKIT_EXPORT WebCryptoKeyUsageMask usages() const;
+    BLINK_EXPORT WebCryptoKeyType type() const;
+    BLINK_EXPORT bool extractable() const;
+    BLINK_EXPORT const WebCryptoAlgorithm& algorithm() const;
+    BLINK_EXPORT WebCryptoKeyUsageMask usages() const;
 
 private:
     WebCryptoKey() { }
-    WEBKIT_EXPORT void assign(const WebCryptoKey& other);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebCryptoKey& other);
+    BLINK_EXPORT void reset();
 
     WebPrivatePtr<WebCryptoKeyPrivate> m_private;
 };
diff --git a/public/platform/WebCursorInfo.h b/public/platform/WebCursorInfo.h
index 123a05f..5d26d02 100644
--- a/public/platform/WebCursorInfo.h
+++ b/public/platform/WebCursorInfo.h
@@ -34,7 +34,7 @@
 #include "WebImage.h"
 #include "WebPoint.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Cursor; }
 #endif
 
@@ -115,7 +115,7 @@
 #endif
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebCursorInfo(const WebCore::Cursor&);
 #endif
 };
diff --git a/public/platform/WebData.h b/public/platform/WebData.h
index 035d4ea..6373a4a 100644
--- a/public/platform/WebData.h
+++ b/public/platform/WebData.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class SharedBuffer; }
 namespace WTF { template <typename T> class PassRefPtr; }
 namespace WTF { template <typename T> class RefPtr; }
@@ -72,17 +72,17 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebData&);
-    WEBKIT_EXPORT void assign(const char* data, size_t size);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebData&);
+    BLINK_EXPORT void assign(const char* data, size_t size);
 
-    WEBKIT_EXPORT size_t size() const;
-    WEBKIT_EXPORT const char* data() const;
+    BLINK_EXPORT size_t size() const;
+    BLINK_EXPORT const char* data() const;
 
     bool isEmpty() const { return !size(); }
     bool isNull() const { return !m_private; }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebData(const WTF::PassRefPtr<WebCore::SharedBuffer>&);
     WebData& operator=(const WTF::PassRefPtr<WebCore::SharedBuffer>&);
     operator WTF::PassRefPtr<WebCore::SharedBuffer>() const;
diff --git a/public/platform/WebDeviceMotionData.h b/public/platform/WebDeviceMotionData.h
index 3284d3a..42d15c1 100644
--- a/public/platform/WebDeviceMotionData.h
+++ b/public/platform/WebDeviceMotionData.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/Assertions.h"
 #endif
 
@@ -43,7 +43,7 @@
 
 class WebDeviceMotionData {
 public:
-    WEBKIT_EXPORT WebDeviceMotionData();
+    BLINK_EXPORT WebDeviceMotionData();
     ~WebDeviceMotionData() { }
 
     double accelerationX;
@@ -75,7 +75,7 @@
     bool allAvailableSensorsAreActive : 1;
 };
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 COMPILE_ASSERT(sizeof(WebDeviceMotionData) == (10 * sizeof(double) + 2 * sizeof(char)), WebDeviceMotionData_has_wrong_size);
 #endif
 
diff --git a/public/platform/WebDeviceOrientationData.h b/public/platform/WebDeviceOrientationData.h
index 072dd09..b52c077 100644
--- a/public/platform/WebDeviceOrientationData.h
+++ b/public/platform/WebDeviceOrientationData.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/Assertions.h"
 #endif
 
@@ -43,7 +43,7 @@
 
 class WebDeviceOrientationData {
 public:
-    WEBKIT_EXPORT WebDeviceOrientationData();
+    BLINK_EXPORT WebDeviceOrientationData();
     ~WebDeviceOrientationData() { }
 
     double alpha;
@@ -60,7 +60,7 @@
     bool allAvailableSensorsAreActive : 1;
 };
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 COMPILE_ASSERT(sizeof(WebDeviceOrientationData) == (3 * sizeof(double) + 1 * sizeof(char)), WebDeviceOrientationData_has_wrong_size);
 #endif
 
diff --git a/public/platform/WebDragData.h b/public/platform/WebDragData.h
index edd3df8..36a60b1 100644
--- a/public/platform/WebDragData.h
+++ b/public/platform/WebDragData.h
@@ -36,7 +36,7 @@
 #include "WebString.h"
 #include "WebURL.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class ChromiumDataObject; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -93,20 +93,20 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebDragData&);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebDragData&);
 
     bool isNull() const { return !m_private; }
 
-    WEBKIT_EXPORT WebVector<Item> items() const;
-    WEBKIT_EXPORT void setItems(const WebVector<Item>&);
-    WEBKIT_EXPORT void addItem(const Item&);
+    BLINK_EXPORT WebVector<Item> items() const;
+    BLINK_EXPORT void setItems(const WebVector<Item>&);
+    BLINK_EXPORT void addItem(const Item&);
 
-    WEBKIT_EXPORT WebString filesystemId() const;
-    WEBKIT_EXPORT void setFilesystemId(const WebString&);
+    BLINK_EXPORT WebString filesystemId() const;
+    BLINK_EXPORT void setFilesystemId(const WebString&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebDragData(const WTF::PassRefPtr<WebCore::ChromiumDataObject>&);
     WebDragData& operator=(const WTF::PassRefPtr<WebCore::ChromiumDataObject>&);
     operator WTF::PassRefPtr<WebCore::ChromiumDataObject>() const;
diff --git a/public/platform/WebFileSystemCallbacks.h b/public/platform/WebFileSystemCallbacks.h
index ece9b5e..aff6098 100644
--- a/public/platform/WebFileSystemCallbacks.h
+++ b/public/platform/WebFileSystemCallbacks.h
@@ -62,52 +62,52 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebFileSystemCallbacks&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebFileSystemCallbacks&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFileSystemCallbacks(const WTF::PassOwnPtr<WebCore::AsyncFileSystemCallbacks>&);
 #endif
 
     // Callback for WebFileSystem's various operations that don't require
     // return values.
-    WEBKIT_EXPORT void didSucceed();
+    BLINK_EXPORT void didSucceed();
 
     // Callback for WebFileSystem::readMetadata. Called with the file metadata
     // for the requested path.
-    WEBKIT_EXPORT void didReadMetadata(const WebFileInfo&);
+    BLINK_EXPORT void didReadMetadata(const WebFileInfo&);
 
     // Callback for WebFileSystem::createSnapshot. The metadata also includes the
     // platform file path.
-    WEBKIT_EXPORT void didCreateSnapshotFile(const WebFileInfo&);
+    BLINK_EXPORT void didCreateSnapshotFile(const WebFileInfo&);
 
     // Callback for WebFileSystem::readDirectory. Called with a vector of
     // file entries in the requested directory. This callback might be called
     // multiple times if the directory has many entries. |hasMore| must be
     // true when there are more entries.
-    WEBKIT_EXPORT void didReadDirectory(const WebVector<WebFileSystemEntry>&, bool hasMore);
+    BLINK_EXPORT void didReadDirectory(const WebVector<WebFileSystemEntry>&, bool hasMore);
 
     // Callback for WebFileSystem::openFileSystem. Called with a name and
     // root URL for the FileSystem when the request is accepted.
-    WEBKIT_EXPORT void didOpenFileSystem(const WebString& name, const WebURL& rootURL);
+    BLINK_EXPORT void didOpenFileSystem(const WebString& name, const WebURL& rootURL);
 
     // Callback for WebFileSystem::resolveURL. Called with a name, root URL and
     // file path for the FileSystem when the request is accepted. |isDirectory|
     // must be true when an entry to be resolved is a directory.
-    WEBKIT_EXPORT void didResolveURL(const WebString& name, const WebURL& rootURL, WebFileSystemType, const WebString& filePath, bool isDirectory);
+    BLINK_EXPORT void didResolveURL(const WebString& name, const WebURL& rootURL, WebFileSystemType, const WebString& filePath, bool isDirectory);
 
     // Callback for WebFileSystem::createFileWriter. Called with an instance
     // of WebFileWriter and the target file length. The writer's ownership
     // is transferred to the callback.
-    WEBKIT_EXPORT void didCreateFileWriter(WebFileWriter*, long long length);
+    BLINK_EXPORT void didCreateFileWriter(WebFileWriter*, long long length);
 
     // Called with an error code when a requested operation hasn't been
     // completed.
-    WEBKIT_EXPORT void didFail(WebFileError);
+    BLINK_EXPORT void didFail(WebFileError);
 
     // Returns true if the caller expects to be blocked until the request
     // is fullfilled.
-    WEBKIT_EXPORT bool shouldBlockUntilCompletion() const;
+    BLINK_EXPORT bool shouldBlockUntilCompletion() const;
 
 private:
     WebPrivatePtr<WebFileSystemCallbacksPrivate> m_private;
diff --git a/public/platform/WebFloatPoint.h b/public/platform/WebFloatPoint.h
index d1df33d..2b42ae0 100644
--- a/public/platform/WebFloatPoint.h
+++ b/public/platform/WebFloatPoint.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/platform/graphics/FloatPoint.h"
 #else
 #include <ui/gfx/point_f.h>
@@ -57,7 +57,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFloatPoint(const WebCore::FloatPoint& p)
         : x(p.x())
         , y(p.y())
diff --git a/public/platform/WebFloatQuad.h b/public/platform/WebFloatQuad.h
index 35180bb..4ac65f7 100644
--- a/public/platform/WebFloatQuad.h
+++ b/public/platform/WebFloatQuad.h
@@ -38,7 +38,7 @@
 #include <algorithm>
 #include <cmath>
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/platform/graphics/FloatQuad.h"
 #endif
 
@@ -59,9 +59,9 @@
         p[3] = p3;
     }
 
-    WEBKIT_EXPORT WebRect enclosingRect() const;
+    BLINK_EXPORT WebRect enclosingRect() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFloatQuad& operator=(const WebCore::FloatQuad& q)
     {
         p[0] = q.p1();
diff --git a/public/platform/WebFloatRect.h b/public/platform/WebFloatRect.h
index 3bb9733..3bf5fe1 100644
--- a/public/platform/WebFloatRect.h
+++ b/public/platform/WebFloatRect.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/platform/graphics/FloatRect.h"
 #else
 #include <cmath>
@@ -66,7 +66,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFloatRect(const WebCore::FloatRect& r)
         : x(r.x())
         , y(r.y())
diff --git a/public/platform/WebFloatSize.h b/public/platform/WebFloatSize.h
index cf8d1b7..8df2fb7 100644
--- a/public/platform/WebFloatSize.h
+++ b/public/platform/WebFloatSize.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/platform/graphics/FloatSize.h"
 #else
 #include <cmath>
@@ -61,7 +61,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFloatSize(const WebCore::FloatSize& s)
         : width(s.width())
         , height(s.height())
diff --git a/public/platform/WebGamepad.h b/public/platform/WebGamepad.h
index a5bc483..148e15e 100644
--- a/public/platform/WebGamepad.h
+++ b/public/platform/WebGamepad.h
@@ -26,7 +26,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/Assertions.h"
 #endif
 
@@ -75,7 +75,7 @@
     float buttons[buttonsLengthCap];
 };
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 COMPILE_ASSERT(sizeof(WebGamepad) == 465, WebGamepad_has_wrong_size);
 #endif
 
diff --git a/public/platform/WebGamepads.h b/public/platform/WebGamepads.h
index 3704924..59cf225 100644
--- a/public/platform/WebGamepads.h
+++ b/public/platform/WebGamepads.h
@@ -26,7 +26,7 @@
 
 #include "WebGamepad.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/Assertions.h"
 #endif
 
@@ -51,7 +51,7 @@
     WebGamepad items[itemsLengthCap];
 };
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 COMPILE_ASSERT(sizeof(WebGamepads) == 1864, WebGamepads_has_wrong_size);
 #endif
 
diff --git a/public/platform/WebHTTPBody.h b/public/platform/WebHTTPBody.h
index c8d8714..2057db4 100644
--- a/public/platform/WebHTTPBody.h
+++ b/public/platform/WebHTTPBody.h
@@ -36,7 +36,7 @@
 #include "WebString.h"
 #include "WebURL.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class FormData; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -74,39 +74,39 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebHTTPBody&);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebHTTPBody&);
 
     bool isNull() const { return !m_private; }
 
     // Returns the number of elements comprising the http body.
-    WEBKIT_EXPORT size_t elementCount() const;
+    BLINK_EXPORT size_t elementCount() const;
 
     // Sets the values of the element at the given index. Returns false if
     // index is out of bounds.
-    WEBKIT_EXPORT bool elementAt(size_t index, Element&) const;
+    BLINK_EXPORT bool elementAt(size_t index, Element&) const;
 
     // Append to the list of elements.
-    WEBKIT_EXPORT void appendData(const WebData&);
-    WEBKIT_EXPORT void appendFile(const WebString&);
+    BLINK_EXPORT void appendData(const WebData&);
+    BLINK_EXPORT void appendFile(const WebString&);
     // Passing -1 to fileLength means to the end of the file.
-    WEBKIT_EXPORT void appendFileRange(const WebString&, long long fileStart, long long fileLength, double modificationTime);
-    WEBKIT_EXPORT void appendBlob(const WebURL&); // FIXME: deprecate this
+    BLINK_EXPORT void appendFileRange(const WebString&, long long fileStart, long long fileLength, double modificationTime);
+    BLINK_EXPORT void appendBlob(const WebURL&); // FIXME: deprecate this
 
     // Append a resource which is identified by the FileSystem URL.
-    WEBKIT_EXPORT void appendFileSystemURLRange(const WebURL&, long long start, long long length, double modificationTime);
-    WEBKIT_EXPORT void appendURLRange(const WebURL&, long long start, long long length, double modificationTime); // DEPRECATED
+    BLINK_EXPORT void appendFileSystemURLRange(const WebURL&, long long start, long long length, double modificationTime);
+    BLINK_EXPORT void appendURLRange(const WebURL&, long long start, long long length, double modificationTime); // DEPRECATED
 
     // Identifies a particular form submission instance. A value of 0 is
     // used to indicate an unspecified identifier.
-    WEBKIT_EXPORT long long identifier() const;
-    WEBKIT_EXPORT void setIdentifier(long long);
+    BLINK_EXPORT long long identifier() const;
+    BLINK_EXPORT void setIdentifier(long long);
 
-    WEBKIT_EXPORT bool containsPasswordData() const;
-    WEBKIT_EXPORT void setContainsPasswordData(bool);
+    BLINK_EXPORT bool containsPasswordData() const;
+    BLINK_EXPORT void setContainsPasswordData(bool);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebHTTPBody(const WTF::PassRefPtr<WebCore::FormData>&);
     WebHTTPBody& operator=(const WTF::PassRefPtr<WebCore::FormData>&);
     operator WTF::PassRefPtr<WebCore::FormData>() const;
diff --git a/public/platform/WebHTTPLoadInfo.h b/public/platform/WebHTTPLoadInfo.h
index 8966e3c..cf678c9 100644
--- a/public/platform/WebHTTPLoadInfo.h
+++ b/public/platform/WebHTTPLoadInfo.h
@@ -52,29 +52,29 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebHTTPLoadInfo& r);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebHTTPLoadInfo& r);
 
-    WEBKIT_EXPORT int httpStatusCode() const;
-    WEBKIT_EXPORT void setHTTPStatusCode(int);
+    BLINK_EXPORT int httpStatusCode() const;
+    BLINK_EXPORT void setHTTPStatusCode(int);
 
-    WEBKIT_EXPORT WebString httpStatusText() const;
-    WEBKIT_EXPORT void setHTTPStatusText(const WebString&);
+    BLINK_EXPORT WebString httpStatusText() const;
+    BLINK_EXPORT void setHTTPStatusText(const WebString&);
 
-    WEBKIT_EXPORT long long encodedDataLength() const;
-    WEBKIT_EXPORT void setEncodedDataLength(long long);
+    BLINK_EXPORT long long encodedDataLength() const;
+    BLINK_EXPORT void setEncodedDataLength(long long);
 
-    WEBKIT_EXPORT void addRequestHeader(const WebString& name, const WebString& value);
-    WEBKIT_EXPORT void addResponseHeader(const WebString& name, const WebString& value);
+    BLINK_EXPORT void addRequestHeader(const WebString& name, const WebString& value);
+    BLINK_EXPORT void addResponseHeader(const WebString& name, const WebString& value);
 
-    WEBKIT_EXPORT WebString requestHeadersText() const;
-    WEBKIT_EXPORT void setRequestHeadersText(const WebString&);
+    BLINK_EXPORT WebString requestHeadersText() const;
+    BLINK_EXPORT void setRequestHeadersText(const WebString&);
 
-    WEBKIT_EXPORT WebString responseHeadersText() const;
-    WEBKIT_EXPORT void setResponseHeadersText(const WebString&);
+    BLINK_EXPORT WebString responseHeadersText() const;
+    BLINK_EXPORT void setResponseHeadersText(const WebString&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebHTTPLoadInfo(WTF::PassRefPtr<WebCore::ResourceLoadInfo>);
     operator WTF::PassRefPtr<WebCore::ResourceLoadInfo>() const;
 #endif
diff --git a/public/platform/WebIDBDatabaseError.h b/public/platform/WebIDBDatabaseError.h
index 6f35b5c..9919b20 100644
--- a/public/platform/WebIDBDatabaseError.h
+++ b/public/platform/WebIDBDatabaseError.h
@@ -51,16 +51,16 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebIDBDatabaseError&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebIDBDatabaseError&);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     operator WTF::PassRefPtr<WebCore::DOMError>() const;
 #endif
 
 private:
-    WEBKIT_EXPORT void assign(unsigned short code);
-    WEBKIT_EXPORT void assign(unsigned short code, const WebString& message);
+    BLINK_EXPORT void assign(unsigned short code);
+    BLINK_EXPORT void assign(unsigned short code, const WebString& message);
 
     WebPrivatePtr<WebCore::DOMError> m_private;
 };
diff --git a/public/platform/WebIDBKey.h b/public/platform/WebIDBKey.h
index 61886f5..48f42d6 100644
--- a/public/platform/WebIDBKey.h
+++ b/public/platform/WebIDBKey.h
@@ -42,12 +42,12 @@
     WebIDBKey() { }
     ~WebIDBKey() { reset(); }
 
-    WEBKIT_EXPORT static WebIDBKey createArray(const WebVector<WebIDBKey>&);
-    WEBKIT_EXPORT static WebIDBKey createString(const WebString&);
-    WEBKIT_EXPORT static WebIDBKey createDate(double);
-    WEBKIT_EXPORT static WebIDBKey createNumber(double);
-    WEBKIT_EXPORT static WebIDBKey createInvalid();
-    WEBKIT_EXPORT static WebIDBKey createNull();
+    BLINK_EXPORT static WebIDBKey createArray(const WebVector<WebIDBKey>&);
+    BLINK_EXPORT static WebIDBKey createString(const WebString&);
+    BLINK_EXPORT static WebIDBKey createDate(double);
+    BLINK_EXPORT static WebIDBKey createNumber(double);
+    BLINK_EXPORT static WebIDBKey createInvalid();
+    BLINK_EXPORT static WebIDBKey createNull();
 
     WebIDBKey(const WebIDBKey& e) { assign(e); }
     WebIDBKey& operator=(const WebIDBKey& e)
@@ -56,23 +56,23 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebIDBKey&);
-    WEBKIT_EXPORT void assignArray(const WebVector<WebIDBKey>&);
-    WEBKIT_EXPORT void assignString(const WebString&);
-    WEBKIT_EXPORT void assignDate(double);
-    WEBKIT_EXPORT void assignNumber(double);
-    WEBKIT_EXPORT void assignInvalid();
-    WEBKIT_EXPORT void assignNull();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebIDBKey&);
+    BLINK_EXPORT void assignArray(const WebVector<WebIDBKey>&);
+    BLINK_EXPORT void assignString(const WebString&);
+    BLINK_EXPORT void assignDate(double);
+    BLINK_EXPORT void assignNumber(double);
+    BLINK_EXPORT void assignInvalid();
+    BLINK_EXPORT void assignNull();
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT WebIDBKeyType keyType() const;
-    WEBKIT_EXPORT bool isValid() const;
-    WEBKIT_EXPORT WebVector<WebIDBKey> array() const; // Only valid for ArrayType.
-    WEBKIT_EXPORT WebString string() const; // Only valid for StringType.
-    WEBKIT_EXPORT double date() const; // Only valid for DateType.
-    WEBKIT_EXPORT double number() const; // Only valid for NumberType.
+    BLINK_EXPORT WebIDBKeyType keyType() const;
+    BLINK_EXPORT bool isValid() const;
+    BLINK_EXPORT WebVector<WebIDBKey> array() const; // Only valid for ArrayType.
+    BLINK_EXPORT WebString string() const; // Only valid for StringType.
+    BLINK_EXPORT double date() const; // Only valid for DateType.
+    BLINK_EXPORT double number() const; // Only valid for NumberType.
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebIDBKey(const WTF::PassRefPtr<WebCore::IDBKey>&);
     WebIDBKey& operator=(const WTF::PassRefPtr<WebCore::IDBKey>&);
     operator WTF::PassRefPtr<WebCore::IDBKey>() const;
diff --git a/public/platform/WebIDBKeyPath.h b/public/platform/WebIDBKeyPath.h
index 74a5841..66b0f6a 100644
--- a/public/platform/WebIDBKeyPath.h
+++ b/public/platform/WebIDBKeyPath.h
@@ -38,9 +38,9 @@
 
 class WebIDBKeyPath {
 public:
-    WEBKIT_EXPORT static WebIDBKeyPath create(const WebString&);
-    WEBKIT_EXPORT static WebIDBKeyPath create(const WebVector<WebString>&);
-    WEBKIT_EXPORT static WebIDBKeyPath createNull();
+    BLINK_EXPORT static WebIDBKeyPath create(const WebString&);
+    BLINK_EXPORT static WebIDBKeyPath create(const WebVector<WebString>&);
+    BLINK_EXPORT static WebIDBKeyPath createNull();
 
     WebIDBKeyPath(const WebIDBKeyPath& keyPath) { assign(keyPath); }
     virtual ~WebIDBKeyPath() { reset(); }
@@ -50,15 +50,15 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebIDBKeyPath&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebIDBKeyPath&);
 
-    WEBKIT_EXPORT bool isValid() const;
-    WEBKIT_EXPORT WebIDBKeyPathType keyPathType() const;
-    WEBKIT_EXPORT WebVector<WebString> array() const; // Only valid for ArrayType.
-    WEBKIT_EXPORT WebString string() const; // Only valid for StringType.
+    BLINK_EXPORT bool isValid() const;
+    BLINK_EXPORT WebIDBKeyPathType keyPathType() const;
+    BLINK_EXPORT WebVector<WebString> array() const; // Only valid for ArrayType.
+    BLINK_EXPORT WebString string() const; // Only valid for StringType.
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebIDBKeyPath(const WebCore::IDBKeyPath&);
     WebIDBKeyPath& operator=(const WebCore::IDBKeyPath&);
     operator const WebCore::IDBKeyPath&() const;
diff --git a/public/platform/WebIDBKeyRange.h b/public/platform/WebIDBKeyRange.h
index adf858e..e71dd86 100644
--- a/public/platform/WebIDBKeyRange.h
+++ b/public/platform/WebIDBKeyRange.h
@@ -43,16 +43,16 @@
     WebIDBKeyRange(const WebIDBKeyRange& keyRange) { assign(keyRange); }
     WebIDBKeyRange(const WebIDBKey& lower, const WebIDBKey& upper, bool lowerOpen, bool upperOpen) { assign(lower, upper, lowerOpen, upperOpen); }
 
-    WEBKIT_EXPORT WebIDBKey lower() const;
-    WEBKIT_EXPORT WebIDBKey upper() const;
-    WEBKIT_EXPORT bool lowerOpen() const;
-    WEBKIT_EXPORT bool upperOpen() const;
+    BLINK_EXPORT WebIDBKey lower() const;
+    BLINK_EXPORT WebIDBKey upper() const;
+    BLINK_EXPORT bool lowerOpen() const;
+    BLINK_EXPORT bool upperOpen() const;
 
-    WEBKIT_EXPORT void assign(const WebIDBKeyRange&);
-    WEBKIT_EXPORT void assign(const WebIDBKey& lower, const WebIDBKey& upper, bool lowerOpen, bool upperOpen);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebIDBKeyRange&);
+    BLINK_EXPORT void assign(const WebIDBKey& lower, const WebIDBKey& upper, bool lowerOpen, bool upperOpen);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebIDBKeyRange(const WTF::PassRefPtr<WebCore::IDBKeyRange>&);
     WebIDBKeyRange& operator=(const WTF::PassRefPtr<WebCore::IDBKeyRange>&);
     operator WTF::PassRefPtr<WebCore::IDBKeyRange>() const;
diff --git a/public/platform/WebIDBMetadata.h b/public/platform/WebIDBMetadata.h
index f9bfb16..8bc913a 100644
--- a/public/platform/WebIDBMetadata.h
+++ b/public/platform/WebIDBMetadata.h
@@ -80,7 +80,7 @@
             , multiEntry(false) { }
     };
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebIDBMetadata(const WebCore::IDBDatabaseMetadata&);
     operator WebCore::IDBDatabaseMetadata() const;
 #endif
diff --git a/public/platform/WebImage.h b/public/platform/WebImage.h
index 82abe1d..ad5f4a8 100644
--- a/public/platform/WebImage.h
+++ b/public/platform/WebImage.h
@@ -36,7 +36,7 @@
 
 #include "third_party/skia/include/core/SkBitmap.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Image; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -67,19 +67,19 @@
     // Decodes the given image data. If the image has multiple frames,
     // then the frame whose size is desiredSize is returned. Otherwise,
     // the first frame is returned.
-    WEBKIT_EXPORT static WebImage fromData(const WebData&, const WebSize& desiredSize);
+    BLINK_EXPORT static WebImage fromData(const WebData&, const WebSize& desiredSize);
 
     // Returns a list of all frames in the image. Only the first frame at each pixel
     // size will be returned.
-    WEBKIT_EXPORT static WebVector<WebImage> framesFromData(const WebData&);
+    BLINK_EXPORT static WebVector<WebImage> framesFromData(const WebData&);
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebImage&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebImage&);
 
-    WEBKIT_EXPORT bool isNull() const;
-    WEBKIT_EXPORT WebSize size() const;
+    BLINK_EXPORT bool isNull() const;
+    BLINK_EXPORT WebSize size() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebImage(const WTF::PassRefPtr<WebCore::Image>&);
     WebImage& operator=(const WTF::PassRefPtr<WebCore::Image>&);
 #endif
diff --git a/public/platform/WebLocalizedString.h b/public/platform/WebLocalizedString.h
index c16c171..1078042 100644
--- a/public/platform/WebLocalizedString.h
+++ b/public/platform/WebLocalizedString.h
@@ -129,7 +129,9 @@
         ValidationBadInputForDateTime,
         ValidationPatternMismatch,
         ValidationRangeOverflow,
+        ValidationRangeOverflowDateTime,
         ValidationRangeUnderflow,
+        ValidationRangeUnderflowDateTime,
         ValidationStepMismatch,
         ValidationStepMismatchCloseToLimit,
         ValidationTooLong,
diff --git a/public/platform/WebMediaConstraints.h b/public/platform/WebMediaConstraints.h
index b2a4471..33bc63b 100644
--- a/public/platform/WebMediaConstraints.h
+++ b/public/platform/WebMediaConstraints.h
@@ -55,7 +55,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebMediaConstraint(const WebCore::MediaConstraint&);
 #endif
 
@@ -75,18 +75,18 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebMediaConstraints&);
+    BLINK_EXPORT void assign(const WebMediaConstraints&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT void getMandatoryConstraints(WebVector<WebMediaConstraint>&) const;
-    WEBKIT_EXPORT void getOptionalConstraints(WebVector<WebMediaConstraint>&) const;
+    BLINK_EXPORT void getMandatoryConstraints(WebVector<WebMediaConstraint>&) const;
+    BLINK_EXPORT void getOptionalConstraints(WebVector<WebMediaConstraint>&) const;
 
-    WEBKIT_EXPORT bool getMandatoryConstraintValue(const WebString& name, WebString& value) const;
-    WEBKIT_EXPORT bool getOptionalConstraintValue(const WebString& name, WebString& value) const;
+    BLINK_EXPORT bool getMandatoryConstraintValue(const WebString& name, WebString& value) const;
+    BLINK_EXPORT bool getOptionalConstraintValue(const WebString& name, WebString& value) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebMediaConstraints(const WTF::PassRefPtr<WebCore::MediaConstraints>&);
     WebMediaConstraints(WebCore::MediaConstraints*);
 #endif
diff --git a/public/platform/WebMediaStream.h b/public/platform/WebMediaStream.h
index e9923dd..87a6706 100644
--- a/public/platform/WebMediaStream.h
+++ b/public/platform/WebMediaStream.h
@@ -57,30 +57,30 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebMediaStream&);
+    BLINK_EXPORT void assign(const WebMediaStream&);
 
-    WEBKIT_EXPORT void initialize(const WebVector<WebMediaStreamTrack>& audioTracks, const WebVector<WebMediaStreamTrack>& videoTracks);
-    WEBKIT_EXPORT void initialize(const WebString& label, const WebVector<WebMediaStreamTrack>& audioTracks, const WebVector<WebMediaStreamTrack>& videoTracks);
+    BLINK_EXPORT void initialize(const WebVector<WebMediaStreamTrack>& audioTracks, const WebVector<WebMediaStreamTrack>& videoTracks);
+    BLINK_EXPORT void initialize(const WebString& label, const WebVector<WebMediaStreamTrack>& audioTracks, const WebVector<WebMediaStreamTrack>& videoTracks);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString id() const;
+    BLINK_EXPORT WebString id() const;
 
-    WEBKIT_EXPORT void audioTracks(WebVector<WebMediaStreamTrack>&) const;
-    WEBKIT_EXPORT void videoTracks(WebVector<WebMediaStreamTrack>&) const;
+    BLINK_EXPORT void audioTracks(WebVector<WebMediaStreamTrack>&) const;
+    BLINK_EXPORT void videoTracks(WebVector<WebMediaStreamTrack>&) const;
 
-    WEBKIT_EXPORT void addTrack(const WebMediaStreamTrack&);
-    WEBKIT_EXPORT void removeTrack(const WebMediaStreamTrack&);
+    BLINK_EXPORT void addTrack(const WebMediaStreamTrack&);
+    BLINK_EXPORT void removeTrack(const WebMediaStreamTrack&);
 
     // Extra data associated with this WebMediaStream.
     // If non-null, the extra data pointer will be deleted when the object is destroyed.
     // Setting the extra data pointer will cause any existing non-null
     // extra data pointer to be deleted.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebMediaStream(WebCore::MediaStreamDescriptor*);
     WebMediaStream(const WTF::PassRefPtr<WebCore::MediaStreamDescriptor>&);
     operator WTF::PassRefPtr<WebCore::MediaStreamDescriptor>() const;
diff --git a/public/platform/WebMediaStreamSource.h b/public/platform/WebMediaStreamSource.h
index 2097b1e..d9113e8 100644
--- a/public/platform/WebMediaStreamSource.h
+++ b/public/platform/WebMediaStreamSource.h
@@ -52,9 +52,9 @@
         ExtraData() : m_owner(0) { }
         virtual ~ExtraData() { }
 
-        WEBKIT_EXPORT WebMediaStreamSource owner();
+        BLINK_EXPORT WebMediaStreamSource owner();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
         void setOwner(WebCore::MediaStreamSource*);
 #endif
 
@@ -83,39 +83,39 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebMediaStreamSource&);
+    BLINK_EXPORT void assign(const WebMediaStreamSource&);
 
-    WEBKIT_EXPORT void initialize(const WebString& id, Type, const WebString& name);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize(const WebString& id, Type, const WebString& name);
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString id() const;
-    WEBKIT_EXPORT Type type() const;
-    WEBKIT_EXPORT WebString name() const;
+    BLINK_EXPORT WebString id() const;
+    BLINK_EXPORT Type type() const;
+    BLINK_EXPORT WebString name() const;
 
-    WEBKIT_EXPORT void setReadyState(ReadyState);
-    WEBKIT_EXPORT ReadyState readyState() const;
+    BLINK_EXPORT void setReadyState(ReadyState);
+    BLINK_EXPORT ReadyState readyState() const;
 
     // Extra data associated with this object.
     // If non-null, the extra data pointer will be deleted when the object is destroyed.
     // Setting the extra data pointer will cause any existing non-null
     // extra data pointer to be deleted.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
-    WEBKIT_EXPORT WebMediaConstraints constraints();
+    BLINK_EXPORT WebMediaConstraints constraints();
 
-    WEBKIT_EXPORT WebString deviceId() const;
-    WEBKIT_EXPORT void setDeviceId(const WebString&);
+    BLINK_EXPORT WebString deviceId() const;
+    BLINK_EXPORT void setDeviceId(const WebString&);
 
     // Only used if if this is a WebAudio source.
     // The WebAudioDestinationConsumer is not owned, and has to be disposed of separately
     // after calling removeAudioConsumer.
-    WEBKIT_EXPORT bool requiresAudioConsumer() const;
-    WEBKIT_EXPORT void addAudioConsumer(WebAudioDestinationConsumer*);
-    WEBKIT_EXPORT bool removeAudioConsumer(WebAudioDestinationConsumer*);
+    BLINK_EXPORT bool requiresAudioConsumer() const;
+    BLINK_EXPORT void addAudioConsumer(WebAudioDestinationConsumer*);
+    BLINK_EXPORT bool removeAudioConsumer(WebAudioDestinationConsumer*);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebMediaStreamSource(const WTF::PassRefPtr<WebCore::MediaStreamSource>&);
     WebMediaStreamSource& operator=(WebCore::MediaStreamSource*);
     operator WTF::PassRefPtr<WebCore::MediaStreamSource>() const;
diff --git a/public/platform/WebMediaStreamTrack.h b/public/platform/WebMediaStreamTrack.h
index 6bd93b6..3696f79 100644
--- a/public/platform/WebMediaStreamTrack.h
+++ b/public/platform/WebMediaStreamTrack.h
@@ -50,26 +50,26 @@
         assign(other);
         return *this;
     }
-    WEBKIT_EXPORT void assign(const WebMediaStreamTrack&);
+    BLINK_EXPORT void assign(const WebMediaStreamTrack&);
 
-    WEBKIT_EXPORT void initialize(const WebMediaStreamSource&);
-    WEBKIT_EXPORT void initialize(const WebString& id, const WebMediaStreamSource&);
+    BLINK_EXPORT void initialize(const WebMediaStreamSource&);
+    BLINK_EXPORT void initialize(const WebString& id, const WebMediaStreamSource&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString id() const;
+    BLINK_EXPORT WebString id() const;
 
-    WEBKIT_EXPORT WebMediaStream stream() const;
-    WEBKIT_EXPORT WebMediaStreamSource source() const;
-    WEBKIT_EXPORT bool isEnabled() const;
+    BLINK_EXPORT WebMediaStream stream() const;
+    BLINK_EXPORT WebMediaStreamSource source() const;
+    BLINK_EXPORT bool isEnabled() const;
 
     // The lifetime of the WebAudioSourceProvider should outlive the
     // WebMediaStreamTrack, and clients are responsible for calling
     // setSourceProvider(0) before the WebMediaStreamTrack is going away.
-    WEBKIT_EXPORT void setSourceProvider(WebAudioSourceProvider*);
+    BLINK_EXPORT void setSourceProvider(WebAudioSourceProvider*);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebMediaStreamTrack(PassRefPtr<WebCore::MediaStreamComponent>);
     WebMediaStreamTrack(WebCore::MediaStreamComponent*);
     WebMediaStreamTrack& operator=(WebCore::MediaStreamComponent*);
diff --git a/public/platform/WebMediaStreamTrackSourcesRequest.h b/public/platform/WebMediaStreamTrackSourcesRequest.h
index 1541fc3..63e1ce3 100644
--- a/public/platform/WebMediaStreamTrackSourcesRequest.h
+++ b/public/platform/WebMediaStreamTrackSourcesRequest.h
@@ -56,22 +56,22 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebMediaStreamTrackSourcesRequest&);
+    BLINK_EXPORT void assign(const WebMediaStreamTrackSourcesRequest&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString origin() const;
-    WEBKIT_EXPORT void requestSucceeded(const WebVector<WebSourceInfo>&) const;
+    BLINK_EXPORT WebString origin() const;
+    BLINK_EXPORT void requestSucceeded(const WebVector<WebSourceInfo>&) const;
 
     // Extra data associated with this object.
     // If non-null, the extra data pointer will be deleted when the object is destroyed.
     // Setting the extra data pointer will cause any existing non-null
     // extra data pointer to be deleted.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebMediaStreamTrackSourcesRequest(const WTF::PassRefPtr<WebCore::MediaStreamTrackSourcesRequest>&);
 #endif
 
diff --git a/public/platform/WebPrerender.h b/public/platform/WebPrerender.h
index c56c6b4..1d2b939 100644
--- a/public/platform/WebPrerender.h
+++ b/public/platform/WebPrerender.h
@@ -37,7 +37,7 @@
 #include "WebString.h"
 #include "WebURL.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/PassRefPtr.h"
 #endif
 
@@ -63,27 +63,27 @@
         return *this;
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebPrerender(PassRefPtr<WebCore::Prerender>);
 
     const WebCore::Prerender* toPrerender() const;
 #endif
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebPrerender&);
-    WEBKIT_EXPORT bool isNull() const;
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebPrerender&);
+    BLINK_EXPORT bool isNull() const;
 
-    WEBKIT_EXPORT WebURL url() const;
-    WEBKIT_EXPORT WebString referrer() const;
-    WEBKIT_EXPORT WebReferrerPolicy referrerPolicy() const;
+    BLINK_EXPORT WebURL url() const;
+    BLINK_EXPORT WebString referrer() const;
+    BLINK_EXPORT WebReferrerPolicy referrerPolicy() const;
 
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
-    WEBKIT_EXPORT const ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT const ExtraData* extraData() const;
 
-    WEBKIT_EXPORT void didStartPrerender();
-    WEBKIT_EXPORT void didStopPrerender();
-    WEBKIT_EXPORT void didSendLoadForPrerender();
-    WEBKIT_EXPORT void didSendDOMContentLoadedForPrerender();
+    BLINK_EXPORT void didStartPrerender();
+    BLINK_EXPORT void didStopPrerender();
+    BLINK_EXPORT void didSendLoadForPrerender();
+    BLINK_EXPORT void didSendDOMContentLoadedForPrerender();
 
 private:
     WebPrivatePtr<WebCore::Prerender> m_private;
diff --git a/public/platform/WebPrerenderingSupport.h b/public/platform/WebPrerenderingSupport.h
index a267291..e31a52f 100644
--- a/public/platform/WebPrerenderingSupport.h
+++ b/public/platform/WebPrerenderingSupport.h
@@ -39,9 +39,9 @@
 
 class WebPrerenderingSupport {
 public:
-    WEBKIT_EXPORT static void initialize(WebPrerenderingSupport*);
-    WEBKIT_EXPORT static void shutdown();
-    WEBKIT_EXPORT static WebPrerenderingSupport* current();
+    BLINK_EXPORT static void initialize(WebPrerenderingSupport*);
+    BLINK_EXPORT static void shutdown();
+    BLINK_EXPORT static WebPrerenderingSupport* current();
 
     // A prerender link element is added when it is inserted into a document.
     virtual void add(const WebPrerender&) = 0;
diff --git a/public/platform/WebPrivatePtr.h b/public/platform/WebPrivatePtr.h
index 0ee9181..3a5ec24 100644
--- a/public/platform/WebPrivatePtr.h
+++ b/public/platform/WebPrivatePtr.h
@@ -56,11 +56,11 @@
 //            assign(other);
 //            return *this;
 //        }
-//        WEBKIT_EXPORT void assign(const WebFoo&);  // Implemented in the body.
+//        BLINK_EXPORT void assign(const WebFoo&);  // Implemented in the body.
 //
 //        // Methods that are exposed to Chromium and which are specific to
 //        // WebFoo go here.
-//        WEBKIT_EXPORT doWebFooThing();
+//        BLINK_EXPORT doWebFooThing();
 //
 //        // Methods that are used only by other WebKit/chromium API classes
 //        // should only be declared when INSIDE_WEBKIT is set.
diff --git a/public/platform/WebRTCConfiguration.h b/public/platform/WebRTCConfiguration.h
index e641ba7..048fbbd 100644
--- a/public/platform/WebRTCConfiguration.h
+++ b/public/platform/WebRTCConfiguration.h
@@ -57,16 +57,16 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCICEServer&);
+    BLINK_EXPORT void assign(const WebRTCICEServer&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebURL uri() const;
-    WEBKIT_EXPORT WebString username() const;
-    WEBKIT_EXPORT WebString credential() const;
+    BLINK_EXPORT WebURL uri() const;
+    BLINK_EXPORT WebString username() const;
+    BLINK_EXPORT WebString credential() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCICEServer(const WTF::PassRefPtr<WebCore::RTCIceServer>&);
 #endif
 
@@ -86,15 +86,15 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCConfiguration&);
+    BLINK_EXPORT void assign(const WebRTCConfiguration&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT size_t numberOfServers() const;
-    WEBKIT_EXPORT WebRTCICEServer server(size_t index) const;
+    BLINK_EXPORT size_t numberOfServers() const;
+    BLINK_EXPORT WebRTCICEServer server(size_t index) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCConfiguration(const WTF::PassRefPtr<WebCore::RTCConfiguration>&);
 #endif
 
diff --git a/public/platform/WebRTCICECandidate.h b/public/platform/WebRTCICECandidate.h
index 37390a5..280ba64 100644
--- a/public/platform/WebRTCICECandidate.h
+++ b/public/platform/WebRTCICECandidate.h
@@ -56,17 +56,17 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCICECandidate&);
+    BLINK_EXPORT void assign(const WebRTCICECandidate&);
 
-    WEBKIT_EXPORT void initialize(const WebString& candidate, const WebString& sdpMid, unsigned short sdpMLineIndex);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize(const WebString& candidate, const WebString& sdpMid, unsigned short sdpMLineIndex);
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString candidate() const;
-    WEBKIT_EXPORT WebString sdpMid() const;
-    WEBKIT_EXPORT unsigned short sdpMLineIndex() const;
+    BLINK_EXPORT WebString candidate() const;
+    BLINK_EXPORT WebString sdpMid() const;
+    BLINK_EXPORT unsigned short sdpMLineIndex() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCICECandidate(WebString candidate, WebString sdpMid, unsigned short sdpMLineIndex)
     {
         this->initialize(candidate, sdpMid, sdpMLineIndex);
diff --git a/public/platform/WebRTCSessionDescription.h b/public/platform/WebRTCSessionDescription.h
index d9147c7..504b6a0 100644
--- a/public/platform/WebRTCSessionDescription.h
+++ b/public/platform/WebRTCSessionDescription.h
@@ -64,18 +64,18 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCSessionDescription&);
+    BLINK_EXPORT void assign(const WebRTCSessionDescription&);
 
-    WEBKIT_EXPORT void initialize(const WebString& type, const WebString& sdp);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize(const WebString& type, const WebString& sdp);
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString type() const;
-    WEBKIT_EXPORT void setType(const WebString&);
-    WEBKIT_EXPORT WebString sdp() const;
-    WEBKIT_EXPORT void setSDP(const WebString&);
+    BLINK_EXPORT WebString type() const;
+    BLINK_EXPORT void setType(const WebString&);
+    BLINK_EXPORT WebString sdp() const;
+    BLINK_EXPORT void setSDP(const WebString&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCSessionDescription(WebString type, WebString sdp)
     {
         this->initialize(type, sdp);
diff --git a/public/platform/WebRTCSessionDescriptionRequest.h b/public/platform/WebRTCSessionDescriptionRequest.h
index dc63565..ca5e78a 100644
--- a/public/platform/WebRTCSessionDescriptionRequest.h
+++ b/public/platform/WebRTCSessionDescriptionRequest.h
@@ -60,22 +60,22 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCSessionDescriptionRequest&);
+    BLINK_EXPORT void assign(const WebRTCSessionDescriptionRequest&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT void requestSucceeded(const WebRTCSessionDescription&) const;
-    WEBKIT_EXPORT void requestFailed(const WebString& error) const;
+    BLINK_EXPORT void requestSucceeded(const WebRTCSessionDescription&) const;
+    BLINK_EXPORT void requestFailed(const WebString& error) const;
 
     // Extra data associated with this object.
     // If non-null, the extra data pointer will be deleted when the object is destroyed.
     // Setting the extra data pointer will cause any existing non-null
     // extra data pointer to be deleted.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCSessionDescriptionRequest(const WTF::PassRefPtr<WebCore::RTCSessionDescriptionRequest>&);
 #endif
 
diff --git a/public/platform/WebRTCStatsRequest.h b/public/platform/WebRTCStatsRequest.h
index 8f9ad30..f5f0d43 100644
--- a/public/platform/WebRTCStatsRequest.h
+++ b/public/platform/WebRTCStatsRequest.h
@@ -78,25 +78,25 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCStatsRequest&);
+    BLINK_EXPORT void assign(const WebRTCStatsRequest&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
     // This function returns true if a selector argument was given to getStats.
-    WEBKIT_EXPORT bool hasSelector() const;
+    BLINK_EXPORT bool hasSelector() const;
 
     // The stream() and component() accessors give the two pieces of information
     // required to look up a MediaStreamTrack implementation.
     // It is only useful to call them when hasSelector() returns true.
-    WEBKIT_EXPORT const WebMediaStream stream() const;
+    BLINK_EXPORT const WebMediaStream stream() const;
 
-    WEBKIT_EXPORT const WebMediaStreamTrack component() const;
+    BLINK_EXPORT const WebMediaStreamTrack component() const;
 
-    WEBKIT_EXPORT void requestSucceeded(const WebRTCStatsResponse&) const;
+    BLINK_EXPORT void requestSucceeded(const WebRTCStatsResponse&) const;
 
-    WEBKIT_EXPORT WebRTCStatsResponse createResponse() const;
+    BLINK_EXPORT WebRTCStatsResponse createResponse() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCStatsRequest(const WTF::PassRefPtr<WebCore::RTCStatsRequest>&);
 #endif
 
diff --git a/public/platform/WebRTCStatsResponse.h b/public/platform/WebRTCStatsResponse.h
index 2a7efdb..32628dc 100644
--- a/public/platform/WebRTCStatsResponse.h
+++ b/public/platform/WebRTCStatsResponse.h
@@ -47,14 +47,14 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCStatsResponse&);
+    BLINK_EXPORT void assign(const WebRTCStatsResponse&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT size_t addReport(WebString id, WebString type, double timestamp);
-    WEBKIT_EXPORT void addStatistic(size_t report, WebString name, WebString value);
+    BLINK_EXPORT size_t addReport(WebString id, WebString type, double timestamp);
+    BLINK_EXPORT void addStatistic(size_t report, WebString name, WebString value);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCStatsResponse(const WTF::PassRefPtr<WebCore::RTCStatsResponseBase>&);
 
     operator WTF::PassRefPtr<WebCore::RTCStatsResponseBase>() const;
diff --git a/public/platform/WebRTCVoidRequest.h b/public/platform/WebRTCVoidRequest.h
index 1256bc6..9bbb875 100644
--- a/public/platform/WebRTCVoidRequest.h
+++ b/public/platform/WebRTCVoidRequest.h
@@ -59,22 +59,22 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebRTCVoidRequest&);
+    BLINK_EXPORT void assign(const WebRTCVoidRequest&);
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT void requestSucceeded() const;
-    WEBKIT_EXPORT void requestFailed(const WebString& error) const;
+    BLINK_EXPORT void requestSucceeded() const;
+    BLINK_EXPORT void requestFailed(const WebString& error) const;
 
     // Extra data associated with this object.
     // If non-null, the extra data pointer will be deleted when the object is destroyed.
     // Setting the extra data pointer will cause any existing non-null
     // extra data pointer to be deleted.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRTCVoidRequest(const WTF::PassRefPtr<WebCore::RTCVoidRequest>&);
 #endif
 
diff --git a/public/platform/WebRect.h b/public/platform/WebRect.h
index 3b711d2..e73aa4c 100644
--- a/public/platform/WebRect.h
+++ b/public/platform/WebRect.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/platform/graphics/IntRect.h"
 #else
 #include <algorithm>
@@ -67,7 +67,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRect(const WebCore::IntRect& r)
         : x(r.x())
         , y(r.y())
diff --git a/public/platform/WebScrollbar.h b/public/platform/WebScrollbar.h
index 06d8d6e..cc2766a 100644
--- a/public/platform/WebScrollbar.h
+++ b/public/platform/WebScrollbar.h
@@ -29,7 +29,7 @@
 #include "WebRect.h"
 #include "WebSize.h"
 #include "WebVector.h"
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/PassOwnPtr.h"
 #endif
 
diff --git a/public/platform/WebScrollbarThemePainter.h b/public/platform/WebScrollbarThemePainter.h
index d9fe5ee..1bd8c56 100644
--- a/public/platform/WebScrollbarThemePainter.h
+++ b/public/platform/WebScrollbarThemePainter.h
@@ -49,20 +49,20 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebScrollbarThemePainter&);
+    BLINK_EXPORT void assign(const WebScrollbarThemePainter&);
 
-    WEBKIT_EXPORT void paintScrollbarBackground(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintTrackBackground(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintBackTrackPart(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintForwardTrackPart(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintBackButtonStart(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintBackButtonEnd(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintForwardButtonStart(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintForwardButtonEnd(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintTickmarks(WebCanvas*, const WebRect&);
-    WEBKIT_EXPORT void paintThumb(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintScrollbarBackground(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintTrackBackground(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintBackTrackPart(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintForwardTrackPart(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintBackButtonStart(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintBackButtonEnd(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintForwardButtonStart(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintForwardButtonEnd(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintTickmarks(WebCanvas*, const WebRect&);
+    BLINK_EXPORT void paintThumb(WebCanvas*, const WebRect&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebScrollbarThemePainter(WebCore::ScrollbarTheme*, WebCore::Scrollbar*);
 #endif
 
diff --git a/public/platform/WebNavigationController.h b/public/platform/WebServiceWorker.h
similarity index 91%
rename from public/platform/WebNavigationController.h
rename to public/platform/WebServiceWorker.h
index be9ca6c..2c93461 100644
--- a/public/platform/WebNavigationController.h
+++ b/public/platform/WebServiceWorker.h
@@ -28,15 +28,15 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WebNavigationController_h
-#define WebNavigationController_h
+#ifndef WebServiceWorker_h
+#define WebServiceWorker_h
 
 namespace WebKit {
 
-class WebNavigationController {
+class WebServiceWorker {
 
 };
 
 }
 
-#endif // WebNavigationController_h
+#endif // WebServiceWorker_h
diff --git a/public/platform/WebNavigationControllerRegistry.h b/public/platform/WebServiceWorkerRegistry.h
similarity index 77%
rename from public/platform/WebNavigationControllerRegistry.h
rename to public/platform/WebServiceWorkerRegistry.h
index b62efbe..3ac2dad 100644
--- a/public/platform/WebNavigationControllerRegistry.h
+++ b/public/platform/WebServiceWorkerRegistry.h
@@ -28,20 +28,23 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WebNavigationControllerRegistry_h
-#define WebNavigationControllerRegistry_h
+#ifndef WebServiceWorkerRegistry_h
+#define WebServiceWorkerRegistry_h
+
+#include "public/platform/WebCallbacks.h"
 
 namespace WebKit {
 
 class WebString;
 class WebURL;
+class WebServiceWorker;
 
-class WebNavigationControllerRegistry {
+class WebServiceWorkerRegistry {
 public:
-    typedef WebCallbacks<WebNavigationController, WebNavigationController> WebNavigationControllerCallbacks;
-    virtual void registerController(const WebString& pattern, const WebURL& scriptUrl, WebNavigationControllerCallbacks*) { }
+    typedef WebCallbacks<WebServiceWorker, WebServiceWorker> WebServiceWorkerCallbacks;
+    virtual void registerServiceWorker(const WebString& pattern, const WebURL& scriptUrl, WebServiceWorkerCallbacks*) { }
 
-    virtual void unregisterController(const WebString& pattern, WebNavigationControllerCallbacks*) { }
+    virtual void unregisterServiceWorker(const WebString& pattern, WebServiceWorkerCallbacks*) { }
 };
 
 } // namespace WebKit
diff --git a/public/platform/WebSize.h b/public/platform/WebSize.h
index d7ef1fc..a5d89bb 100644
--- a/public/platform/WebSize.h
+++ b/public/platform/WebSize.h
@@ -33,7 +33,7 @@
 
 #include "WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/platform/graphics/IntSize.h"
 #else
 #include <algorithm>
@@ -62,7 +62,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSize(const WebCore::IntSize& s)
         : width(s.width())
         , height(s.height())
diff --git a/public/platform/WebSocketHandle.h b/public/platform/WebSocketHandle.h
index 08bca08..0708f2f 100644
--- a/public/platform/WebSocketHandle.h
+++ b/public/platform/WebSocketHandle.h
@@ -41,23 +41,29 @@
 class WebURL;
 
 // FIXME: This class will replace WebSocketStreamHandle.
+//
+// WebSocketHandle is an interface class designed to be a handle of WebSocket connection.
+// WebSocketHandle will be used together with WebSocketHandleClient.
+//
+// Once a WebSocketHandle is deleted there will be no notification to the corresponding WebSocketHandleClient.
+// Once a WebSocketHandleClient receives DidClose, any method of the corresponding WebSocketHandle can't be called.
+
 class WebSocketHandle {
 public:
     enum MessageType {
+        MessageTypeContinuation,
         MessageTypeText,
         MessageTypeBinary,
-        MessageTypeContinuation,
     };
 
     virtual ~WebSocketHandle() { }
 
     virtual void connect(const WebURL& /* url */, const WebVector<WebString>& protocols, const WebString& origin, WebSocketHandleClient*) = 0;
-    virtual void send(MessageType, const char* data, size_t /* size */, bool fin) = 0;
-    virtual void flowControl(int64_t quota);
+    virtual void send(bool fin, MessageType, const char* data, size_t /* size */) = 0;
+    virtual void flowControl(int64_t quota) = 0;
     virtual void close(unsigned short code, const WebString& reason) = 0;
 };
 
 } // namespace WebKit
 
 #endif // WebSocketHandle_h
-
diff --git a/public/platform/WebSocketHandleClient.h b/public/platform/WebSocketHandleClient.h
index 6bc286d..a503c2d 100644
--- a/public/platform/WebSocketHandleClient.h
+++ b/public/platform/WebSocketHandleClient.h
@@ -43,10 +43,10 @@
 class WebSocketHandleClient {
 public:
     // Called when the handle is opened.
-    virtual void didConnect(WebSocketHandle*, bool succeed, const WebString& selectedProtocol, const WebString& extensions) = 0;
+    virtual void didConnect(WebSocketHandle*, bool fail, const WebString& selectedProtocol, const WebString& extensions) = 0;
 
     // Called when data are received.
-    virtual void didReceiveData(WebSocketHandle*, WebSocketHandle::MessageType, const char* data, size_t /* size */, bool fin) = 0;
+    virtual void didReceiveData(WebSocketHandle*, bool fin, WebSocketHandle::MessageType, const char* data, size_t /* size */) = 0;
 
     // Called when the handle is closed.
     virtual void didClose(WebSocketHandle*, unsigned short code, const WebString& reason) = 0;
diff --git a/public/platform/WebSocketStreamError.h b/public/platform/WebSocketStreamError.h
index 33ac96c..4373cb8 100644
--- a/public/platform/WebSocketStreamError.h
+++ b/public/platform/WebSocketStreamError.h
@@ -34,7 +34,7 @@
 #include "WebCommon.h"
 #include "WebPrivatePtr.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/PassRefPtr.h"
 #endif
 
@@ -50,11 +50,11 @@
     WebSocketStreamError(const WebSocketStreamError& other) { assign(other); }
     ~WebSocketStreamError() { reset(); }
 
-    WEBKIT_EXPORT void assign(int code, const WebString& message);
-    WEBKIT_EXPORT void assign(const WebSocketStreamError&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(int code, const WebString& message);
+    BLINK_EXPORT void assign(const WebSocketStreamError&);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSocketStreamError(WTF::PassRefPtr<WebCore::SocketStreamError>);
     WebSocketStreamError& operator=(WTF::PassRefPtr<WebCore::SocketStreamError>);
     operator WTF::PassRefPtr<WebCore::SocketStreamError>() const;
diff --git a/public/platform/WebSourceInfo.h b/public/platform/WebSourceInfo.h
index 0ae96e7..dff1148 100644
--- a/public/platform/WebSourceInfo.h
+++ b/public/platform/WebSourceInfo.h
@@ -59,16 +59,16 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebSourceInfo&);
+    BLINK_EXPORT void assign(const WebSourceInfo&);
 
-    WEBKIT_EXPORT void initialize(const WebString& id, SourceKind, const WebString& label, VideoFacingMode);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize(const WebString& id, SourceKind, const WebString& label, VideoFacingMode);
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString id() const;
-    WEBKIT_EXPORT SourceKind kind() const;
-    WEBKIT_EXPORT WebString label() const;
-    WEBKIT_EXPORT VideoFacingMode facing() const;
+    BLINK_EXPORT WebString id() const;
+    BLINK_EXPORT SourceKind kind() const;
+    BLINK_EXPORT WebString label() const;
+    BLINK_EXPORT VideoFacingMode facing() const;
 
 private:
     WebPrivatePtr<WebSourceInfoPrivate> m_private;
diff --git a/public/platform/WebSpeechSynthesisUtterance.h b/public/platform/WebSpeechSynthesisUtterance.h
index 44197f2..0e314c7 100644
--- a/public/platform/WebSpeechSynthesisUtterance.h
+++ b/public/platform/WebSpeechSynthesisUtterance.h
@@ -46,22 +46,22 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebSpeechSynthesisUtterance&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebSpeechSynthesisUtterance&);
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString text() const;
-    WEBKIT_EXPORT WebString lang() const;
-    WEBKIT_EXPORT WebString voice() const;
+    BLINK_EXPORT WebString text() const;
+    BLINK_EXPORT WebString lang() const;
+    BLINK_EXPORT WebString voice() const;
 
     // As defined in: https://dvcs.w3.org/hg/speech-api/raw-file/tip/speechapi.html
-    WEBKIT_EXPORT float volume() const; // 0...1, 1 is default
-    WEBKIT_EXPORT float rate() const; // 0.1...10, 1 is default
-    WEBKIT_EXPORT float pitch() const; // 0...2, 1 is default
+    BLINK_EXPORT float volume() const; // 0...1, 1 is default
+    BLINK_EXPORT float rate() const; // 0.1...10, 1 is default
+    BLINK_EXPORT float pitch() const; // 0...2, 1 is default
 
-    WEBKIT_EXPORT double startTime() const; // In seconds.
+    BLINK_EXPORT double startTime() const; // In seconds.
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSpeechSynthesisUtterance(const PassRefPtr<WebCore::PlatformSpeechSynthesisUtterance>&);
     WebSpeechSynthesisUtterance& operator=(WebCore::PlatformSpeechSynthesisUtterance*);
     operator PassRefPtr<WebCore::PlatformSpeechSynthesisUtterance>() const;
diff --git a/public/platform/WebSpeechSynthesisVoice.h b/public/platform/WebSpeechSynthesisVoice.h
index 8e7e747..a4011a7 100644
--- a/public/platform/WebSpeechSynthesisVoice.h
+++ b/public/platform/WebSpeechSynthesisVoice.h
@@ -38,7 +38,7 @@
 
 class WebSpeechSynthesisVoice {
 public:
-    WEBKIT_EXPORT WebSpeechSynthesisVoice();
+    BLINK_EXPORT WebSpeechSynthesisVoice();
     WebSpeechSynthesisVoice(const WebSpeechSynthesisVoice& other) { assign(other); }
     ~WebSpeechSynthesisVoice() { reset(); }
 
@@ -48,16 +48,16 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebSpeechSynthesisVoice&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebSpeechSynthesisVoice&);
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT void setVoiceURI(const WebString&);
-    WEBKIT_EXPORT void setName(const WebString&);
-    WEBKIT_EXPORT void setLanguage(const WebString&);
-    WEBKIT_EXPORT void setIsLocalService(bool);
-    WEBKIT_EXPORT void setIsDefault(bool);
+    BLINK_EXPORT void setVoiceURI(const WebString&);
+    BLINK_EXPORT void setName(const WebString&);
+    BLINK_EXPORT void setLanguage(const WebString&);
+    BLINK_EXPORT void setIsLocalService(bool);
+    BLINK_EXPORT void setIsDefault(bool);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     operator WTF::PassRefPtr<WebCore::PlatformSpeechSynthesisVoice>() const;
 #endif
 
diff --git a/public/platform/WebThreadSafeData.h b/public/platform/WebThreadSafeData.h
index 19af4df..367ca03 100644
--- a/public/platform/WebThreadSafeData.h
+++ b/public/platform/WebThreadSafeData.h
@@ -34,7 +34,7 @@
 #include "WebCommon.h"
 #include "WebPrivatePtr.h"
 
-#if !WEBKIT_IMPLEMENTATION
+#if !BLINK_IMPLEMENTATION
 #include <string>
 #endif
 
@@ -49,15 +49,15 @@
     WebThreadSafeData() { }
     ~WebThreadSafeData() { reset(); }
 
-    WEBKIT_EXPORT void assign(const WebThreadSafeData&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebThreadSafeData&);
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT size_t size() const;
-    WEBKIT_EXPORT const char* data() const;
+    BLINK_EXPORT size_t size() const;
+    BLINK_EXPORT const char* data() const;
 
     bool isEmpty() const { return !size(); }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebThreadSafeData(const WTF::PassRefPtr<WebCore::RawData>&);
     WebThreadSafeData& operator=(const WTF::PassRefPtr<WebCore::RawData>&);
 #else
diff --git a/public/platform/WebTransformKeyframe.h b/public/platform/WebTransformKeyframe.h
index a505d9a..464bebb 100644
--- a/public/platform/WebTransformKeyframe.h
+++ b/public/platform/WebTransformKeyframe.h
@@ -33,13 +33,13 @@
 class WebTransformKeyframe {
 public:
     // Takes ownership of the WebTranformOperations object.
-    WEBKIT_EXPORT WebTransformKeyframe(double time, WebTransformOperations* value);
+    BLINK_EXPORT WebTransformKeyframe(double time, WebTransformOperations* value);
 
-    WEBKIT_EXPORT ~WebTransformKeyframe();
+    BLINK_EXPORT ~WebTransformKeyframe();
 
-    WEBKIT_EXPORT double time() const;
+    BLINK_EXPORT double time() const;
 
-    WEBKIT_EXPORT const WebTransformOperations& value() const;
+    BLINK_EXPORT const WebTransformOperations& value() const;
 
 private:
     double m_time;
diff --git a/public/platform/WebURL.h b/public/platform/WebURL.h
index 994305e..fe53c75 100644
--- a/public/platform/WebURL.h
+++ b/public/platform/WebURL.h
@@ -35,7 +35,7 @@
 #include "WebString.h"
 #include <url/third_party/mozilla/url_parse.h>
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class KURL; }
 #else
 #include <url/gurl.h>
@@ -101,7 +101,7 @@
         return m_string.isEmpty();
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebURL(const WebCore::KURL&);
     WebURL& operator=(const WebCore::KURL&);
     operator WebCore::KURL() const;
diff --git a/public/platform/WebURLError.h b/public/platform/WebURLError.h
index b6b2858..9aff423 100644
--- a/public/platform/WebURLError.h
+++ b/public/platform/WebURLError.h
@@ -34,7 +34,7 @@
 #include "WebString.h"
 #include "WebURL.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class ResourceError; }
 #endif
 
@@ -64,7 +64,7 @@
 
     WebURLError() : reason(0), isCancellation(false) { }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebURLError(const WebCore::ResourceError&);
     WebURLError& operator=(const WebCore::ResourceError&);
     operator WebCore::ResourceError() const;
diff --git a/public/platform/WebURLLoadTiming.h b/public/platform/WebURLLoadTiming.h
index 07f15d2..b942e28 100644
--- a/public/platform/WebURLLoadTiming.h
+++ b/public/platform/WebURLLoadTiming.h
@@ -51,49 +51,49 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebURLLoadTiming&);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebURLLoadTiming&);
 
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT double requestTime() const;
-    WEBKIT_EXPORT void setRequestTime(double);
+    BLINK_EXPORT double requestTime() const;
+    BLINK_EXPORT void setRequestTime(double);
 
-    WEBKIT_EXPORT double proxyStart() const;
-    WEBKIT_EXPORT void setProxyStart(double);
+    BLINK_EXPORT double proxyStart() const;
+    BLINK_EXPORT void setProxyStart(double);
 
-    WEBKIT_EXPORT double proxyEnd() const;
-    WEBKIT_EXPORT void setProxyEnd(double);
+    BLINK_EXPORT double proxyEnd() const;
+    BLINK_EXPORT void setProxyEnd(double);
 
-    WEBKIT_EXPORT double dnsStart() const;
-    WEBKIT_EXPORT void setDNSStart(double);
+    BLINK_EXPORT double dnsStart() const;
+    BLINK_EXPORT void setDNSStart(double);
 
-    WEBKIT_EXPORT double dnsEnd() const;
-    WEBKIT_EXPORT void setDNSEnd(double);
+    BLINK_EXPORT double dnsEnd() const;
+    BLINK_EXPORT void setDNSEnd(double);
 
-    WEBKIT_EXPORT double connectStart() const;
-    WEBKIT_EXPORT void setConnectStart(double);
+    BLINK_EXPORT double connectStart() const;
+    BLINK_EXPORT void setConnectStart(double);
 
-    WEBKIT_EXPORT double connectEnd() const;
-    WEBKIT_EXPORT void setConnectEnd(double);
+    BLINK_EXPORT double connectEnd() const;
+    BLINK_EXPORT void setConnectEnd(double);
 
-    WEBKIT_EXPORT double sendStart() const;
-    WEBKIT_EXPORT void setSendStart(double);
+    BLINK_EXPORT double sendStart() const;
+    BLINK_EXPORT void setSendStart(double);
 
-    WEBKIT_EXPORT double sendEnd() const;
-    WEBKIT_EXPORT void setSendEnd(double);
+    BLINK_EXPORT double sendEnd() const;
+    BLINK_EXPORT void setSendEnd(double);
 
-    WEBKIT_EXPORT double receiveHeadersEnd() const;
-    WEBKIT_EXPORT void setReceiveHeadersEnd(double);
+    BLINK_EXPORT double receiveHeadersEnd() const;
+    BLINK_EXPORT void setReceiveHeadersEnd(double);
 
-    WEBKIT_EXPORT double sslStart() const;
-    WEBKIT_EXPORT void setSSLStart(double);
+    BLINK_EXPORT double sslStart() const;
+    BLINK_EXPORT void setSSLStart(double);
 
-    WEBKIT_EXPORT double sslEnd() const;
-    WEBKIT_EXPORT void setSSLEnd(double);
+    BLINK_EXPORT double sslEnd() const;
+    BLINK_EXPORT void setSSLEnd(double);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebURLLoadTiming(const WTF::PassRefPtr<WebCore::ResourceLoadTiming>&);
     WebURLLoadTiming& operator=(const WTF::PassRefPtr<WebCore::ResourceLoadTiming>&);
     operator WTF::PassRefPtr<WebCore::ResourceLoadTiming>() const;
diff --git a/public/platform/WebURLRequest.h b/public/platform/WebURLRequest.h
index b1f8d0f..48bcec6 100644
--- a/public/platform/WebURLRequest.h
+++ b/public/platform/WebURLRequest.h
@@ -34,7 +34,7 @@
 #include "WebCommon.h"
 #include "WebHTTPBody.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class ResourceRequest; }
 #endif
 
@@ -105,81 +105,81 @@
         setURL(url);
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebURLRequest&);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebURLRequest&);
 
-    WEBKIT_EXPORT bool isNull() const;
+    BLINK_EXPORT bool isNull() const;
 
-    WEBKIT_EXPORT WebURL url() const;
-    WEBKIT_EXPORT void setURL(const WebURL&);
+    BLINK_EXPORT WebURL url() const;
+    BLINK_EXPORT void setURL(const WebURL&);
 
     // Used to implement third-party cookie blocking.
-    WEBKIT_EXPORT WebURL firstPartyForCookies() const;
-    WEBKIT_EXPORT void setFirstPartyForCookies(const WebURL&);
+    BLINK_EXPORT WebURL firstPartyForCookies() const;
+    BLINK_EXPORT void setFirstPartyForCookies(const WebURL&);
 
-    WEBKIT_EXPORT bool allowCookies() const;
-    WEBKIT_EXPORT void setAllowCookies(bool);
+    BLINK_EXPORT bool allowCookies() const;
+    BLINK_EXPORT void setAllowCookies(bool);
 
     // Controls whether user name, password, and cookies may be sent with the
     // request. (If false, this overrides allowCookies.)
-    WEBKIT_EXPORT bool allowStoredCredentials() const;
-    WEBKIT_EXPORT void setAllowStoredCredentials(bool);
+    BLINK_EXPORT bool allowStoredCredentials() const;
+    BLINK_EXPORT void setAllowStoredCredentials(bool);
 
-    WEBKIT_EXPORT CachePolicy cachePolicy() const;
-    WEBKIT_EXPORT void setCachePolicy(CachePolicy);
+    BLINK_EXPORT CachePolicy cachePolicy() const;
+    BLINK_EXPORT void setCachePolicy(CachePolicy);
 
-    WEBKIT_EXPORT WebString httpMethod() const;
-    WEBKIT_EXPORT void setHTTPMethod(const WebString&);
+    BLINK_EXPORT WebString httpMethod() const;
+    BLINK_EXPORT void setHTTPMethod(const WebString&);
 
-    WEBKIT_EXPORT WebString httpHeaderField(const WebString& name) const;
-    WEBKIT_EXPORT void setHTTPHeaderField(const WebString& name, const WebString& value);
-    WEBKIT_EXPORT void addHTTPHeaderField(const WebString& name, const WebString& value);
-    WEBKIT_EXPORT void clearHTTPHeaderField(const WebString& name);
-    WEBKIT_EXPORT void visitHTTPHeaderFields(WebHTTPHeaderVisitor*) const;
+    BLINK_EXPORT WebString httpHeaderField(const WebString& name) const;
+    BLINK_EXPORT void setHTTPHeaderField(const WebString& name, const WebString& value);
+    BLINK_EXPORT void addHTTPHeaderField(const WebString& name, const WebString& value);
+    BLINK_EXPORT void clearHTTPHeaderField(const WebString& name);
+    BLINK_EXPORT void visitHTTPHeaderFields(WebHTTPHeaderVisitor*) const;
 
-    WEBKIT_EXPORT WebHTTPBody httpBody() const;
-    WEBKIT_EXPORT void setHTTPBody(const WebHTTPBody&);
+    BLINK_EXPORT WebHTTPBody httpBody() const;
+    BLINK_EXPORT void setHTTPBody(const WebHTTPBody&);
 
     // Controls whether upload progress events are generated when a request
     // has a body.
-    WEBKIT_EXPORT bool reportUploadProgress() const;
-    WEBKIT_EXPORT void setReportUploadProgress(bool);
+    BLINK_EXPORT bool reportUploadProgress() const;
+    BLINK_EXPORT void setReportUploadProgress(bool);
 
     // Controls whether load timing info is collected for the request.
-    WEBKIT_EXPORT bool reportLoadTiming() const;
-    WEBKIT_EXPORT void setReportLoadTiming(bool);
+    BLINK_EXPORT bool reportLoadTiming() const;
+    BLINK_EXPORT void setReportLoadTiming(bool);
 
     // Controls whether actual headers sent and received for request are
     // collected and reported.
-    WEBKIT_EXPORT bool reportRawHeaders() const;
-    WEBKIT_EXPORT void setReportRawHeaders(bool);
+    BLINK_EXPORT bool reportRawHeaders() const;
+    BLINK_EXPORT void setReportRawHeaders(bool);
 
-    WEBKIT_EXPORT TargetType targetType() const;
-    WEBKIT_EXPORT void setTargetType(TargetType);
+    BLINK_EXPORT TargetType targetType() const;
+    BLINK_EXPORT void setTargetType(TargetType);
 
     // True if the request was user initiated.
-    WEBKIT_EXPORT bool hasUserGesture() const;
-    WEBKIT_EXPORT void setHasUserGesture(bool);
+    BLINK_EXPORT bool hasUserGesture() const;
+    BLINK_EXPORT void setHasUserGesture(bool);
 
     // A consumer controlled value intended to be used to identify the
     // requestor.
-    WEBKIT_EXPORT int requestorID() const;
-    WEBKIT_EXPORT void setRequestorID(int);
+    BLINK_EXPORT int requestorID() const;
+    BLINK_EXPORT void setRequestorID(int);
 
     // A consumer controlled value intended to be used to identify the
     // process of the requestor.
-    WEBKIT_EXPORT int requestorProcessID() const;
-    WEBKIT_EXPORT void setRequestorProcessID(int);
+    BLINK_EXPORT int requestorProcessID() const;
+    BLINK_EXPORT void setRequestorProcessID(int);
 
     // Allows the request to be matched up with its app cache host.
-    WEBKIT_EXPORT int appCacheHostID() const;
-    WEBKIT_EXPORT void setAppCacheHostID(int);
+    BLINK_EXPORT int appCacheHostID() const;
+    BLINK_EXPORT void setAppCacheHostID(int);
 
     // If true, the response body will be downloaded to a file managed by the
     // WebURLLoader. See WebURLResponse::downloadedFilePath.
-    WEBKIT_EXPORT bool downloadToFile() const;
-    WEBKIT_EXPORT void setDownloadToFile(bool);
+    BLINK_EXPORT bool downloadToFile() const;
+    BLINK_EXPORT void setDownloadToFile(bool);
 
     // Extra data associated with the underlying resource request. Resource
     // requests can be copied. If non-null, each copy of a resource requests
@@ -187,12 +187,12 @@
     // deleted when the last resource request is destroyed. Setting the extra
     // data pointer will cause the underlying resource request to be
     // dissociated from any existing non-null extra data pointer.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
-    WEBKIT_EXPORT Priority priority() const;
+    BLINK_EXPORT Priority priority() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebCore::ResourceRequest& toMutableResourceRequest();
     const WebCore::ResourceRequest& toResourceRequest() const;
 #endif
diff --git a/public/platform/WebURLResponse.h b/public/platform/WebURLResponse.h
index 36a1d86..d36edc9 100644
--- a/public/platform/WebURLResponse.h
+++ b/public/platform/WebURLResponse.h
@@ -34,7 +34,7 @@
 #include "WebCommon.h"
 #include "WebPrivateOwnPtr.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class ResourceResponse; }
 #endif
 
@@ -73,116 +73,116 @@
         setURL(url);
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebURLResponse&);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebURLResponse&);
 
-    WEBKIT_EXPORT bool isNull() const;
+    BLINK_EXPORT bool isNull() const;
 
-    WEBKIT_EXPORT WebURL url() const;
-    WEBKIT_EXPORT void setURL(const WebURL&);
+    BLINK_EXPORT WebURL url() const;
+    BLINK_EXPORT void setURL(const WebURL&);
 
-    WEBKIT_EXPORT unsigned connectionID() const;
-    WEBKIT_EXPORT void setConnectionID(unsigned);
+    BLINK_EXPORT unsigned connectionID() const;
+    BLINK_EXPORT void setConnectionID(unsigned);
 
-    WEBKIT_EXPORT bool connectionReused() const;
-    WEBKIT_EXPORT void setConnectionReused(bool);
+    BLINK_EXPORT bool connectionReused() const;
+    BLINK_EXPORT void setConnectionReused(bool);
 
-    WEBKIT_EXPORT WebURLLoadTiming loadTiming();
-    WEBKIT_EXPORT void setLoadTiming(const WebURLLoadTiming&);
+    BLINK_EXPORT WebURLLoadTiming loadTiming();
+    BLINK_EXPORT void setLoadTiming(const WebURLLoadTiming&);
 
-    WEBKIT_EXPORT WebHTTPLoadInfo httpLoadInfo();
-    WEBKIT_EXPORT void setHTTPLoadInfo(const WebHTTPLoadInfo&);
+    BLINK_EXPORT WebHTTPLoadInfo httpLoadInfo();
+    BLINK_EXPORT void setHTTPLoadInfo(const WebHTTPLoadInfo&);
 
-    WEBKIT_EXPORT double responseTime() const;
-    WEBKIT_EXPORT void setResponseTime(double);
+    BLINK_EXPORT double responseTime() const;
+    BLINK_EXPORT void setResponseTime(double);
 
-    WEBKIT_EXPORT WebString mimeType() const;
-    WEBKIT_EXPORT void setMIMEType(const WebString&);
+    BLINK_EXPORT WebString mimeType() const;
+    BLINK_EXPORT void setMIMEType(const WebString&);
 
-    WEBKIT_EXPORT long long expectedContentLength() const;
-    WEBKIT_EXPORT void setExpectedContentLength(long long);
+    BLINK_EXPORT long long expectedContentLength() const;
+    BLINK_EXPORT void setExpectedContentLength(long long);
 
-    WEBKIT_EXPORT WebString textEncodingName() const;
-    WEBKIT_EXPORT void setTextEncodingName(const WebString&);
+    BLINK_EXPORT WebString textEncodingName() const;
+    BLINK_EXPORT void setTextEncodingName(const WebString&);
 
-    WEBKIT_EXPORT WebString suggestedFileName() const;
-    WEBKIT_EXPORT void setSuggestedFileName(const WebString&);
+    BLINK_EXPORT WebString suggestedFileName() const;
+    BLINK_EXPORT void setSuggestedFileName(const WebString&);
 
-    WEBKIT_EXPORT HTTPVersion httpVersion() const;
-    WEBKIT_EXPORT void setHTTPVersion(HTTPVersion);
+    BLINK_EXPORT HTTPVersion httpVersion() const;
+    BLINK_EXPORT void setHTTPVersion(HTTPVersion);
 
-    WEBKIT_EXPORT int httpStatusCode() const;
-    WEBKIT_EXPORT void setHTTPStatusCode(int);
+    BLINK_EXPORT int httpStatusCode() const;
+    BLINK_EXPORT void setHTTPStatusCode(int);
 
-    WEBKIT_EXPORT WebString httpStatusText() const;
-    WEBKIT_EXPORT void setHTTPStatusText(const WebString&);
+    BLINK_EXPORT WebString httpStatusText() const;
+    BLINK_EXPORT void setHTTPStatusText(const WebString&);
 
-    WEBKIT_EXPORT WebString httpHeaderField(const WebString& name) const;
-    WEBKIT_EXPORT void setHTTPHeaderField(const WebString& name, const WebString& value);
-    WEBKIT_EXPORT void addHTTPHeaderField(const WebString& name, const WebString& value);
-    WEBKIT_EXPORT void clearHTTPHeaderField(const WebString& name);
-    WEBKIT_EXPORT void visitHTTPHeaderFields(WebHTTPHeaderVisitor*) const;
+    BLINK_EXPORT WebString httpHeaderField(const WebString& name) const;
+    BLINK_EXPORT void setHTTPHeaderField(const WebString& name, const WebString& value);
+    BLINK_EXPORT void addHTTPHeaderField(const WebString& name, const WebString& value);
+    BLINK_EXPORT void clearHTTPHeaderField(const WebString& name);
+    BLINK_EXPORT void visitHTTPHeaderFields(WebHTTPHeaderVisitor*) const;
 
-    WEBKIT_EXPORT double lastModifiedDate() const;
-    WEBKIT_EXPORT void setLastModifiedDate(double);
+    BLINK_EXPORT double lastModifiedDate() const;
+    BLINK_EXPORT void setLastModifiedDate(double);
 
-    WEBKIT_EXPORT long long appCacheID() const;
-    WEBKIT_EXPORT void setAppCacheID(long long);
+    BLINK_EXPORT long long appCacheID() const;
+    BLINK_EXPORT void setAppCacheID(long long);
 
-    WEBKIT_EXPORT WebURL appCacheManifestURL() const;
-    WEBKIT_EXPORT void setAppCacheManifestURL(const WebURL&);
+    BLINK_EXPORT WebURL appCacheManifestURL() const;
+    BLINK_EXPORT void setAppCacheManifestURL(const WebURL&);
 
     // A consumer controlled value intended to be used to record opaque
     // security info related to this request.
-    WEBKIT_EXPORT WebCString securityInfo() const;
-    WEBKIT_EXPORT void setSecurityInfo(const WebCString&);
+    BLINK_EXPORT WebCString securityInfo() const;
+    BLINK_EXPORT void setSecurityInfo(const WebCString&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebCore::ResourceResponse& toMutableResourceResponse();
     const WebCore::ResourceResponse& toResourceResponse() const;
 #endif
 
     // Flag whether this request was served from the disk cache entry.
-    WEBKIT_EXPORT bool wasCached() const;
-    WEBKIT_EXPORT void setWasCached(bool);
+    BLINK_EXPORT bool wasCached() const;
+    BLINK_EXPORT void setWasCached(bool);
 
     // Flag whether this request was loaded via the SPDY protocol or not.
     // SPDY is an experimental web protocol, see http://dev.chromium.org/spdy
-    WEBKIT_EXPORT bool wasFetchedViaSPDY() const;
-    WEBKIT_EXPORT void setWasFetchedViaSPDY(bool);
+    BLINK_EXPORT bool wasFetchedViaSPDY() const;
+    BLINK_EXPORT void setWasFetchedViaSPDY(bool);
 
     // Flag whether this request was loaded after the TLS/Next-Protocol-Negotiation was used.
     // This is related to SPDY.
-    WEBKIT_EXPORT bool wasNpnNegotiated() const;
-    WEBKIT_EXPORT void setWasNpnNegotiated(bool);
+    BLINK_EXPORT bool wasNpnNegotiated() const;
+    BLINK_EXPORT void setWasNpnNegotiated(bool);
 
     // Flag whether this request was made when "Alternate-Protocol: xxx"
     // is present in server's response.
-    WEBKIT_EXPORT bool wasAlternateProtocolAvailable() const;
-    WEBKIT_EXPORT void setWasAlternateProtocolAvailable(bool);
+    BLINK_EXPORT bool wasAlternateProtocolAvailable() const;
+    BLINK_EXPORT void setWasAlternateProtocolAvailable(bool);
 
     // Flag whether this request was loaded via an explicit proxy (HTTP, SOCKS, etc).
-    WEBKIT_EXPORT bool wasFetchedViaProxy() const;
-    WEBKIT_EXPORT void setWasFetchedViaProxy(bool);
+    BLINK_EXPORT bool wasFetchedViaProxy() const;
+    BLINK_EXPORT void setWasFetchedViaProxy(bool);
 
     // Flag whether this request is part of a multipart response.
-    WEBKIT_EXPORT bool isMultipartPayload() const;
-    WEBKIT_EXPORT void setIsMultipartPayload(bool);
+    BLINK_EXPORT bool isMultipartPayload() const;
+    BLINK_EXPORT void setIsMultipartPayload(bool);
 
     // This indicates the location of a downloaded response if the
     // WebURLRequest had the downloadToFile flag set to true. This file path
     // remains valid for the lifetime of the WebURLLoader used to create it.
-    WEBKIT_EXPORT WebString downloadFilePath() const;
-    WEBKIT_EXPORT void setDownloadFilePath(const WebString&);
+    BLINK_EXPORT WebString downloadFilePath() const;
+    BLINK_EXPORT void setDownloadFilePath(const WebString&);
 
     // Remote IP address of the socket which fetched this resource.
-    WEBKIT_EXPORT WebString remoteIPAddress() const;
-    WEBKIT_EXPORT void setRemoteIPAddress(const WebString&);
+    BLINK_EXPORT WebString remoteIPAddress() const;
+    BLINK_EXPORT void setRemoteIPAddress(const WebString&);
 
     // Remote port number of the socket which fetched this resource.
-    WEBKIT_EXPORT unsigned short remotePort() const;
-    WEBKIT_EXPORT void setRemotePort(unsigned short);
+    BLINK_EXPORT unsigned short remotePort() const;
+    BLINK_EXPORT void setRemotePort(unsigned short);
 
     // Extra data associated with the underlying resource response. Resource
     // responses can be copied. If non-null, each copy of a resource response
@@ -190,8 +190,8 @@
     // deleted when the last resource response is destroyed. Setting the extra
     // data pointer will cause the underlying resource response to be
     // dissociated from any existing non-null extra data pointer.
-    WEBKIT_EXPORT ExtraData* extraData() const;
-    WEBKIT_EXPORT void setExtraData(ExtraData*);
+    BLINK_EXPORT ExtraData* extraData() const;
+    BLINK_EXPORT void setExtraData(ExtraData*);
 
 protected:
     void assign(WebURLResponsePrivate*);
diff --git a/public/platform/WebWorkerRunLoop.h b/public/platform/WebWorkerRunLoop.h
index cf7225d..417dc30 100644
--- a/public/platform/WebWorkerRunLoop.h
+++ b/public/platform/WebWorkerRunLoop.h
@@ -42,11 +42,11 @@
     };
 
     // Returns true if the task was posted to a non-terminated loop.
-    WEBKIT_EXPORT bool postTask(Task*);
-    WEBKIT_EXPORT bool equals(const WebWorkerRunLoop&) const;
-    WEBKIT_EXPORT bool lessThan(const WebWorkerRunLoop&) const;
+    BLINK_EXPORT bool postTask(Task*);
+    BLINK_EXPORT bool equals(const WebWorkerRunLoop&) const;
+    BLINK_EXPORT bool lessThan(const WebWorkerRunLoop&) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebWorkerRunLoop(WebCore::WorkerRunLoop*);
 #endif
 
diff --git a/public/platform/linux/WebFontInfo.h b/public/platform/linux/WebFontInfo.h
index ab13110..afd6fc4 100644
--- a/public/platform/linux/WebFontInfo.h
+++ b/public/platform/linux/WebFontInfo.h
@@ -45,7 +45,7 @@
     // Set a global preference describing whether renderStyleForStrike() should
     // enable subpixel positioning or not. FontConfig doesn't currently provide
     // a parameter for controlling this.
-    WEBKIT_EXPORT static void setSubpixelPositioning(bool);
+    BLINK_EXPORT static void setSubpixelPositioning(bool);
 
     // Return a font family which provides a glyph for the Unicode code point
     // specified by character.
@@ -55,7 +55,7 @@
     //
     // Returns: the font family or an empty string if the request could not be satisfied.
     // Returns: the font family instance. The instance has an empty font name if the request could not be satisfied.
-    WEBKIT_EXPORT static void familyForChar(const WebUChar32 character, const char* preferredLocale, WebFontFamily*);
+    BLINK_EXPORT static void familyForChar(const WebUChar32 character, const char* preferredLocale, WebFontFamily*);
 
     // Fill out the given WebFontRenderStyle with the user's preferences for
     // rendering the given font at the given size (in pixels).
@@ -68,7 +68,7 @@
     //     +--------------------------------+
     //     I: italic flag
     //     B: bold flag
-    WEBKIT_EXPORT static void renderStyleForStrike(const char* family, int sizeAndStyle, WebFontRenderStyle* result);
+    BLINK_EXPORT static void renderStyleForStrike(const char* family, int sizeAndStyle, WebFontRenderStyle* result);
 };
 
 } // namespace WebKit
diff --git a/public/platform/linux/WebFontRenderStyle.h b/public/platform/linux/WebFontRenderStyle.h
index 919d05c..65669b2 100644
--- a/public/platform/linux/WebFontRenderStyle.h
+++ b/public/platform/linux/WebFontRenderStyle.h
@@ -37,7 +37,7 @@
 
 namespace WebKit {
 
-struct WEBKIT_EXPORT WebFontRenderStyle {
+struct BLINK_EXPORT WebFontRenderStyle {
     // Each of the use* members below can take one of three values:
     //   0: off
     //   1: on
@@ -50,7 +50,7 @@
     char useSubpixelRendering; // use subpixel rendering (partially-filled pixels)
     char useSubpixelPositioning; // use subpixel positioning (fractional X positions for glyphs)
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     // Translates the members of this struct to a FontRenderStyle
     void toFontRenderStyle(WebCore::FontRenderStyle*);
 #endif
diff --git a/public/web/WebAXObject.h b/public/web/WebAXObject.h
index 8106a14..e836912 100644
--- a/public/web/WebAXObject.h
+++ b/public/web/WebAXObject.h
@@ -36,7 +36,7 @@
 #include "../platform/WebVector.h"
 #include "WebAXEnums.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
 
@@ -64,145 +64,145 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebAXObject&);
-    WEBKIT_EXPORT bool equals(const WebAXObject&) const;
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebAXObject&);
+    BLINK_EXPORT bool equals(const WebAXObject&) const;
 
     bool isNull() const { return m_private.isNull(); }
     // isDetached also checks for null, so it's safe to just call isDetached.
-    WEBKIT_EXPORT bool isDetached() const;
+    BLINK_EXPORT bool isDetached() const;
 
     // Static methods for enabling accessibility.
-    WEBKIT_EXPORT static void enableAccessibility();
-    WEBKIT_EXPORT static bool accessibilityEnabled();
+    BLINK_EXPORT static void enableAccessibility();
+    BLINK_EXPORT static bool accessibilityEnabled();
 
-    WEBKIT_EXPORT void startCachingComputedObjectAttributesUntilTreeMutates();
-    WEBKIT_EXPORT void stopCachingComputedObjectAttributes();
+    BLINK_EXPORT void startCachingComputedObjectAttributesUntilTreeMutates();
+    BLINK_EXPORT void stopCachingComputedObjectAttributes();
 
-    WEBKIT_EXPORT int axID() const;
+    BLINK_EXPORT int axID() const;
 
     // Update the underlying tree, and return true if this object is
     // still valid (not detached). Note that calling this method
     // can cause other WebAXObjects to become invalid, too,
     // so always call isDetached if updateBackingStoreAndCheckValidity
     // has been called on any object, or if any other WebCore code has run.
-    WEBKIT_EXPORT bool updateBackingStoreAndCheckValidity();
+    BLINK_EXPORT bool updateBackingStoreAndCheckValidity();
 
-    WEBKIT_EXPORT WebString accessibilityDescription() const;
-    WEBKIT_EXPORT unsigned childCount() const;
+    BLINK_EXPORT WebString accessibilityDescription() const;
+    BLINK_EXPORT unsigned childCount() const;
 
-    WEBKIT_EXPORT WebAXObject childAt(unsigned) const;
-    WEBKIT_EXPORT WebAXObject parentObject() const;
+    BLINK_EXPORT WebAXObject childAt(unsigned) const;
+    BLINK_EXPORT WebAXObject parentObject() const;
 
-    WEBKIT_EXPORT bool isAnchor() const;
-    WEBKIT_EXPORT bool isAriaReadOnly() const;
-    WEBKIT_EXPORT bool isButtonStateMixed() const;
-    WEBKIT_EXPORT bool isChecked() const;
-    WEBKIT_EXPORT bool isClickable() const;
-    WEBKIT_EXPORT bool isCollapsed() const;
-    WEBKIT_EXPORT bool isControl() const;
-    WEBKIT_EXPORT bool isEnabled() const;
-    WEBKIT_EXPORT bool isFocused() const;
-    WEBKIT_EXPORT bool isHovered() const;
-    WEBKIT_EXPORT bool isIndeterminate() const;
-    WEBKIT_EXPORT bool isLinked() const;
-    WEBKIT_EXPORT bool isLoaded() const;
-    WEBKIT_EXPORT bool isMultiSelectable() const;
-    WEBKIT_EXPORT bool isOffScreen() const;
-    WEBKIT_EXPORT bool isPasswordField() const;
-    WEBKIT_EXPORT bool isPressed() const;
-    WEBKIT_EXPORT bool isReadOnly() const;
-    WEBKIT_EXPORT bool isRequired() const;
-    WEBKIT_EXPORT bool isSelected() const;
-    WEBKIT_EXPORT bool isSelectedOptionActive() const;
-    WEBKIT_EXPORT bool isVertical() const;
-    WEBKIT_EXPORT bool isVisible() const;
-    WEBKIT_EXPORT bool isVisited() const;
+    BLINK_EXPORT bool isAnchor() const;
+    BLINK_EXPORT bool isAriaReadOnly() const;
+    BLINK_EXPORT bool isButtonStateMixed() const;
+    BLINK_EXPORT bool isChecked() const;
+    BLINK_EXPORT bool isClickable() const;
+    BLINK_EXPORT bool isCollapsed() const;
+    BLINK_EXPORT bool isControl() const;
+    BLINK_EXPORT bool isEnabled() const;
+    BLINK_EXPORT bool isFocused() const;
+    BLINK_EXPORT bool isHovered() const;
+    BLINK_EXPORT bool isIndeterminate() const;
+    BLINK_EXPORT bool isLinked() const;
+    BLINK_EXPORT bool isLoaded() const;
+    BLINK_EXPORT bool isMultiSelectable() const;
+    BLINK_EXPORT bool isOffScreen() const;
+    BLINK_EXPORT bool isPasswordField() const;
+    BLINK_EXPORT bool isPressed() const;
+    BLINK_EXPORT bool isReadOnly() const;
+    BLINK_EXPORT bool isRequired() const;
+    BLINK_EXPORT bool isSelected() const;
+    BLINK_EXPORT bool isSelectedOptionActive() const;
+    BLINK_EXPORT bool isVertical() const;
+    BLINK_EXPORT bool isVisible() const;
+    BLINK_EXPORT bool isVisited() const;
 
-    WEBKIT_EXPORT WebString accessKey() const;
-    WEBKIT_EXPORT bool ariaHasPopup() const;
-    WEBKIT_EXPORT bool ariaLiveRegionAtomic() const;
-    WEBKIT_EXPORT bool ariaLiveRegionBusy() const;
-    WEBKIT_EXPORT WebString ariaLiveRegionRelevant() const;
-    WEBKIT_EXPORT WebString ariaLiveRegionStatus() const;
-    WEBKIT_EXPORT WebRect boundingBoxRect() const;
-    WEBKIT_EXPORT bool canvasHasFallbackContent() const;
-    WEBKIT_EXPORT WebPoint clickPoint() const;
-    WEBKIT_EXPORT void colorValue(int& r, int& g, int& b) const;
-    WEBKIT_EXPORT double estimatedLoadingProgress() const;
-    WEBKIT_EXPORT WebString helpText() const;
-    WEBKIT_EXPORT int headingLevel() const;
-    WEBKIT_EXPORT int hierarchicalLevel() const;
-    WEBKIT_EXPORT WebAXObject hitTest(const WebPoint&) const;
-    WEBKIT_EXPORT WebString keyboardShortcut() const;
-    WEBKIT_EXPORT WebAXRole role() const;
-    WEBKIT_EXPORT unsigned selectionEnd() const;
-    WEBKIT_EXPORT unsigned selectionEndLineNumber() const;
-    WEBKIT_EXPORT unsigned selectionStart() const;
-    WEBKIT_EXPORT unsigned selectionStartLineNumber() const;
-    WEBKIT_EXPORT WebString stringValue() const;
-    WEBKIT_EXPORT WebString title() const;
-    WEBKIT_EXPORT WebAXObject titleUIElement() const;
-    WEBKIT_EXPORT WebURL url() const;
+    BLINK_EXPORT WebString accessKey() const;
+    BLINK_EXPORT bool ariaHasPopup() const;
+    BLINK_EXPORT bool ariaLiveRegionAtomic() const;
+    BLINK_EXPORT bool ariaLiveRegionBusy() const;
+    BLINK_EXPORT WebString ariaLiveRegionRelevant() const;
+    BLINK_EXPORT WebString ariaLiveRegionStatus() const;
+    BLINK_EXPORT WebRect boundingBoxRect() const;
+    BLINK_EXPORT bool canvasHasFallbackContent() const;
+    BLINK_EXPORT WebPoint clickPoint() const;
+    BLINK_EXPORT void colorValue(int& r, int& g, int& b) const;
+    BLINK_EXPORT double estimatedLoadingProgress() const;
+    BLINK_EXPORT WebString helpText() const;
+    BLINK_EXPORT int headingLevel() const;
+    BLINK_EXPORT int hierarchicalLevel() const;
+    BLINK_EXPORT WebAXObject hitTest(const WebPoint&) const;
+    BLINK_EXPORT WebString keyboardShortcut() const;
+    BLINK_EXPORT WebAXRole role() const;
+    BLINK_EXPORT unsigned selectionEnd() const;
+    BLINK_EXPORT unsigned selectionEndLineNumber() const;
+    BLINK_EXPORT unsigned selectionStart() const;
+    BLINK_EXPORT unsigned selectionStartLineNumber() const;
+    BLINK_EXPORT WebString stringValue() const;
+    BLINK_EXPORT WebString title() const;
+    BLINK_EXPORT WebAXObject titleUIElement() const;
+    BLINK_EXPORT WebURL url() const;
 
-    WEBKIT_EXPORT bool supportsRangeValue() const;
-    WEBKIT_EXPORT WebString valueDescription() const;
-    WEBKIT_EXPORT float valueForRange() const;
-    WEBKIT_EXPORT float maxValueForRange() const;
-    WEBKIT_EXPORT float minValueForRange() const;
+    BLINK_EXPORT bool supportsRangeValue() const;
+    BLINK_EXPORT WebString valueDescription() const;
+    BLINK_EXPORT float valueForRange() const;
+    BLINK_EXPORT float maxValueForRange() const;
+    BLINK_EXPORT float minValueForRange() const;
 
-    WEBKIT_EXPORT WebNode node() const;
-    WEBKIT_EXPORT WebDocument document() const;
-    WEBKIT_EXPORT bool hasComputedStyle() const;
-    WEBKIT_EXPORT WebString computedStyleDisplay() const;
-    WEBKIT_EXPORT bool accessibilityIsIgnored() const;
-    WEBKIT_EXPORT bool lineBreaks(WebVector<int>&) const;
+    BLINK_EXPORT WebNode node() const;
+    BLINK_EXPORT WebDocument document() const;
+    BLINK_EXPORT bool hasComputedStyle() const;
+    BLINK_EXPORT WebString computedStyleDisplay() const;
+    BLINK_EXPORT bool accessibilityIsIgnored() const;
+    BLINK_EXPORT bool lineBreaks(WebVector<int>&) const;
 
     // Actions
-    WEBKIT_EXPORT WebString actionVerb() const; // The verb corresponding to performDefaultAction.
-    WEBKIT_EXPORT bool canDecrement() const;
-    WEBKIT_EXPORT bool canIncrement() const;
-    WEBKIT_EXPORT bool canPress() const;
-    WEBKIT_EXPORT bool canSetFocusAttribute() const;
-    WEBKIT_EXPORT bool canSetSelectedAttribute() const;
-    WEBKIT_EXPORT bool canSetValueAttribute() const;
-    WEBKIT_EXPORT bool performDefaultAction() const;
-    WEBKIT_EXPORT bool press() const;
-    WEBKIT_EXPORT bool increment() const;
-    WEBKIT_EXPORT bool decrement() const;
-    WEBKIT_EXPORT void setFocused(bool) const;
-    WEBKIT_EXPORT void setSelectedTextRange(int selectionStart, int selectionEnd) const;
+    BLINK_EXPORT WebString actionVerb() const; // The verb corresponding to performDefaultAction.
+    BLINK_EXPORT bool canDecrement() const;
+    BLINK_EXPORT bool canIncrement() const;
+    BLINK_EXPORT bool canPress() const;
+    BLINK_EXPORT bool canSetFocusAttribute() const;
+    BLINK_EXPORT bool canSetSelectedAttribute() const;
+    BLINK_EXPORT bool canSetValueAttribute() const;
+    BLINK_EXPORT bool performDefaultAction() const;
+    BLINK_EXPORT bool press() const;
+    BLINK_EXPORT bool increment() const;
+    BLINK_EXPORT bool decrement() const;
+    BLINK_EXPORT void setFocused(bool) const;
+    BLINK_EXPORT void setSelectedTextRange(int selectionStart, int selectionEnd) const;
 
     // For a table
-    WEBKIT_EXPORT unsigned columnCount() const;
-    WEBKIT_EXPORT unsigned rowCount() const;
-    WEBKIT_EXPORT WebAXObject cellForColumnAndRow(unsigned column, unsigned row) const;
-    WEBKIT_EXPORT WebAXObject headerContainerObject() const;
-    WEBKIT_EXPORT WebAXObject rowAtIndex(unsigned rowIndex) const;
-    WEBKIT_EXPORT WebAXObject columnAtIndex(unsigned columnIndex) const;
+    BLINK_EXPORT unsigned columnCount() const;
+    BLINK_EXPORT unsigned rowCount() const;
+    BLINK_EXPORT WebAXObject cellForColumnAndRow(unsigned column, unsigned row) const;
+    BLINK_EXPORT WebAXObject headerContainerObject() const;
+    BLINK_EXPORT WebAXObject rowAtIndex(unsigned rowIndex) const;
+    BLINK_EXPORT WebAXObject columnAtIndex(unsigned columnIndex) const;
 
     // For a table row
-    WEBKIT_EXPORT unsigned rowIndex() const;
-    WEBKIT_EXPORT WebAXObject rowHeader() const;
+    BLINK_EXPORT unsigned rowIndex() const;
+    BLINK_EXPORT WebAXObject rowHeader() const;
 
     // For a table column
-    WEBKIT_EXPORT unsigned columnIndex() const;
-    WEBKIT_EXPORT WebAXObject columnHeader() const;
+    BLINK_EXPORT unsigned columnIndex() const;
+    BLINK_EXPORT WebAXObject columnHeader() const;
 
     // For a table cell
-    WEBKIT_EXPORT unsigned cellColumnIndex() const;
-    WEBKIT_EXPORT unsigned cellColumnSpan() const;
-    WEBKIT_EXPORT unsigned cellRowIndex() const;
-    WEBKIT_EXPORT unsigned cellRowSpan() const;
+    BLINK_EXPORT unsigned cellColumnIndex() const;
+    BLINK_EXPORT unsigned cellColumnSpan() const;
+    BLINK_EXPORT unsigned cellRowIndex() const;
+    BLINK_EXPORT unsigned cellRowSpan() const;
 
     // Make this object visible by scrolling as many nested scrollable views as needed.
-    WEBKIT_EXPORT void scrollToMakeVisible() const;
+    BLINK_EXPORT void scrollToMakeVisible() const;
     // Same, but if the whole object can't be made visible, try for this subrect, in local coordinates.
-    WEBKIT_EXPORT void scrollToMakeVisibleWithSubFocus(const WebRect&) const;
+    BLINK_EXPORT void scrollToMakeVisibleWithSubFocus(const WebRect&) const;
     // Scroll this object to a given point in global coordinates of the top-level window.
-    WEBKIT_EXPORT void scrollToGlobalPoint(const WebPoint&) const;
+    BLINK_EXPORT void scrollToGlobalPoint(const WebPoint&) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebAXObject(const WTF::PassRefPtr<WebCore::AccessibilityObject>&);
     WebAXObject& operator=(const WTF::PassRefPtr<WebCore::AccessibilityObject>&);
     operator WTF::PassRefPtr<WebCore::AccessibilityObject>() const;
diff --git a/public/web/WebArrayBufferView.h b/public/web/WebArrayBufferView.h
index db29119..51a28b9 100644
--- a/public/web/WebArrayBufferView.h
+++ b/public/web/WebArrayBufferView.h
@@ -48,16 +48,16 @@
     WebArrayBufferView() { }
     WebArrayBufferView(const WebArrayBufferView& v) { assign(v); }
 
-    WEBKIT_EXPORT void* baseAddress() const;
-    WEBKIT_EXPORT unsigned byteOffset() const;
-    WEBKIT_EXPORT unsigned byteLength() const;
+    BLINK_EXPORT void* baseAddress() const;
+    BLINK_EXPORT unsigned byteOffset() const;
+    BLINK_EXPORT unsigned byteLength() const;
 
-    WEBKIT_EXPORT void assign(const WebArrayBufferView&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebArrayBufferView&);
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT static WebArrayBufferView* createFromV8Value(v8::Handle<v8::Value>);
+    BLINK_EXPORT static WebArrayBufferView* createFromV8Value(v8::Handle<v8::Value>);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebArrayBufferView(const WTF::PassRefPtr<WTF::ArrayBufferView>&);
     WebArrayBufferView& operator=(const WTF::PassRefPtr<WTF::ArrayBufferView>&);
     operator WTF::PassRefPtr<WTF::ArrayBufferView>() const;
diff --git a/public/web/WebBindings.h b/public/web/WebBindings.h
index 2ae8f4d..8e2a550 100644
--- a/public/web/WebBindings.h
+++ b/public/web/WebBindings.h
@@ -58,117 +58,117 @@
     // These are all defined in npruntime.h and are well documented.
 
     // NPN_Construct
-    WEBKIT_EXPORT static bool construct(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant* result);
+    BLINK_EXPORT static bool construct(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant* result);
 
     // NPN_CreateObject
-    WEBKIT_EXPORT static NPObject* createObject(NPP, NPClass*);
+    BLINK_EXPORT static NPObject* createObject(NPP, NPClass*);
 
     // NPN_Enumerate
-    WEBKIT_EXPORT static bool enumerate(NPP, NPObject*, NPIdentifier**, uint32_t* identifierCount);
+    BLINK_EXPORT static bool enumerate(NPP, NPObject*, NPIdentifier**, uint32_t* identifierCount);
 
     // NPN_Evaluate
-    WEBKIT_EXPORT static bool evaluate(NPP, NPObject*, NPString* script, NPVariant* result);
+    BLINK_EXPORT static bool evaluate(NPP, NPObject*, NPString* script, NPVariant* result);
 
     // NPN_EvaluateHelper
-    WEBKIT_EXPORT static bool evaluateHelper(NPP, bool popupsAllowed, NPObject*, NPString* script, NPVariant* result);
+    BLINK_EXPORT static bool evaluateHelper(NPP, bool popupsAllowed, NPObject*, NPString* script, NPVariant* result);
 
     // NPN_GetIntIdentifier
-    WEBKIT_EXPORT static NPIdentifier getIntIdentifier(int32_t number);
+    BLINK_EXPORT static NPIdentifier getIntIdentifier(int32_t number);
 
     // NPN_GetProperty
-    WEBKIT_EXPORT static bool getProperty(NPP, NPObject*, NPIdentifier property, NPVariant *result);
+    BLINK_EXPORT static bool getProperty(NPP, NPObject*, NPIdentifier property, NPVariant *result);
 
     // NPN_GetStringIdentifier
-    WEBKIT_EXPORT static NPIdentifier getStringIdentifier(const NPUTF8* string);
+    BLINK_EXPORT static NPIdentifier getStringIdentifier(const NPUTF8* string);
 
     // NPN_GetStringIdentifiers
-    WEBKIT_EXPORT static void getStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier*);
+    BLINK_EXPORT static void getStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier*);
 
     // NPN_HasMethod
-    WEBKIT_EXPORT static bool hasMethod(NPP, NPObject*, NPIdentifier method);
+    BLINK_EXPORT static bool hasMethod(NPP, NPObject*, NPIdentifier method);
 
     // NPN_HasProperty
-    WEBKIT_EXPORT static bool hasProperty(NPP, NPObject*, NPIdentifier property);
+    BLINK_EXPORT static bool hasProperty(NPP, NPObject*, NPIdentifier property);
 
     // NPN_IdentifierIsString
-    WEBKIT_EXPORT static bool identifierIsString(NPIdentifier);
+    BLINK_EXPORT static bool identifierIsString(NPIdentifier);
 
     // NPN_InitializeVariantWithStringCopy (though sometimes prefixed with an underscore)
-    WEBKIT_EXPORT static void initializeVariantWithStringCopy(NPVariant*, const NPString*);
+    BLINK_EXPORT static void initializeVariantWithStringCopy(NPVariant*, const NPString*);
 
     // NPN_IntFromIdentifier
-    WEBKIT_EXPORT static int32_t intFromIdentifier(NPIdentifier);
+    BLINK_EXPORT static int32_t intFromIdentifier(NPIdentifier);
 
     // NPN_Invoke
-    WEBKIT_EXPORT static bool invoke(NPP, NPObject*, NPIdentifier method, const NPVariant* args, uint32_t argCount, NPVariant* result);
+    BLINK_EXPORT static bool invoke(NPP, NPObject*, NPIdentifier method, const NPVariant* args, uint32_t argCount, NPVariant* result);
 
     // NPN_InvokeDefault
-    WEBKIT_EXPORT static bool invokeDefault(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant* result);
+    BLINK_EXPORT static bool invokeDefault(NPP, NPObject*, const NPVariant* args, uint32_t argCount, NPVariant* result);
 
     // NPN_ReleaseObject
-    WEBKIT_EXPORT static void releaseObject(NPObject*);
+    BLINK_EXPORT static void releaseObject(NPObject*);
 
     // NPN_ReleaseVariantValue
-    WEBKIT_EXPORT static void releaseVariantValue(NPVariant*);
+    BLINK_EXPORT static void releaseVariantValue(NPVariant*);
 
     // NPN_RemoveProperty
-    WEBKIT_EXPORT static bool removeProperty(NPP, NPObject*, NPIdentifier);
+    BLINK_EXPORT static bool removeProperty(NPP, NPObject*, NPIdentifier);
 
     // NPN_RetainObject
-    WEBKIT_EXPORT static NPObject* retainObject(NPObject*);
+    BLINK_EXPORT static NPObject* retainObject(NPObject*);
 
     // NPN_SetException
-    WEBKIT_EXPORT static void setException(NPObject*, const NPUTF8* message);
+    BLINK_EXPORT static void setException(NPObject*, const NPUTF8* message);
 
     // NPN_SetProperty
-    WEBKIT_EXPORT static bool setProperty(NPP, NPObject*, NPIdentifier, const NPVariant*);
+    BLINK_EXPORT static bool setProperty(NPP, NPObject*, NPIdentifier, const NPVariant*);
 
     // _NPN_RegisterObjectOwner
-    WEBKIT_EXPORT static void registerObjectOwner(NPP);
+    BLINK_EXPORT static void registerObjectOwner(NPP);
 
     // _NPN_UnregisterObjectOwner
-    WEBKIT_EXPORT static void unregisterObjectOwner(NPP);
+    BLINK_EXPORT static void unregisterObjectOwner(NPP);
 
     // Temporary dummy implementation of _NPN_GetObjectOwner.
-    WEBKIT_EXPORT static NPP getObjectOwner(NPObject*);
+    BLINK_EXPORT static NPP getObjectOwner(NPObject*);
 
     // _NPN_UnregisterObject
-    WEBKIT_EXPORT static void unregisterObject(NPObject*);
+    BLINK_EXPORT static void unregisterObject(NPObject*);
 
     // NPN_UTF8FromIdentifier
-    WEBKIT_EXPORT static NPUTF8* utf8FromIdentifier(NPIdentifier);
+    BLINK_EXPORT static NPUTF8* utf8FromIdentifier(NPIdentifier);
 
     // Miscellaneous utility functions ----------------------------------------
 
     // Complement to NPN_Get___Identifier functions.  Extracts data from the NPIdentifier data
     // structure.  If isString is true upon return, string will be set but number's value is
     // undefined.  If iString is false, the opposite is true.
-    WEBKIT_EXPORT static void extractIdentifierData(const NPIdentifier&, const NPUTF8*& string, int32_t& number, bool& isString);
+    BLINK_EXPORT static void extractIdentifierData(const NPIdentifier&, const NPUTF8*& string, int32_t& number, bool& isString);
 
     // DumpRenderTree support -------------------------------------------------
 
     // Return true (success) if the given npobj is a range object.
     // If so, return that range as a WebRange object.
-    WEBKIT_EXPORT static bool getRange(NPObject* range, WebRange*);
+    BLINK_EXPORT static bool getRange(NPObject* range, WebRange*);
 
     // Return true (success) if the given npobj is an ArrayBuffer object.
     // If so, return it as a WebArrayBuffer object.
-    WEBKIT_EXPORT static bool getArrayBuffer(NPObject* arrayBuffer, WebArrayBuffer*);
+    BLINK_EXPORT static bool getArrayBuffer(NPObject* arrayBuffer, WebArrayBuffer*);
 
     // Return true (success) if the given npobj is an ArrayBufferView object.
     // If so, return it as a WebArrayBufferView object.
-    WEBKIT_EXPORT static bool getArrayBufferView(NPObject* arrayBufferView, WebArrayBufferView*);
+    BLINK_EXPORT static bool getArrayBufferView(NPObject* arrayBufferView, WebArrayBufferView*);
 
     // Return true (success) if the given npobj is a node.
     // If so, return that node as a WebNode object.
-    WEBKIT_EXPORT static bool getNode(NPObject* element, WebNode*);
+    BLINK_EXPORT static bool getNode(NPObject* element, WebNode*);
 
     // Return true (success) if the given npobj is an element.
     // If so, return that element as a WebElement object.
-    WEBKIT_EXPORT static bool getElement(NPObject* element, WebElement*);
+    BLINK_EXPORT static bool getElement(NPObject* element, WebElement*);
 
-    WEBKIT_EXPORT static NPObject* makeIntArray(const WebVector<int>&);
-    WEBKIT_EXPORT static NPObject* makeStringArray(const WebVector<WebString>&);
+    BLINK_EXPORT static NPObject* makeIntArray(const WebVector<int>&);
+    BLINK_EXPORT static NPObject* makeStringArray(const WebVector<WebString>&);
 
     // Exceptions -------------------------------------------------------------
 
@@ -176,12 +176,12 @@
 
     // The exception handler will be notified of any exceptions thrown while
     // operating on a NPObject.
-    WEBKIT_EXPORT static void pushExceptionHandler(ExceptionHandler, void* data);
-    WEBKIT_EXPORT static void popExceptionHandler();
+    BLINK_EXPORT static void pushExceptionHandler(ExceptionHandler, void* data);
+    BLINK_EXPORT static void popExceptionHandler();
 
     // Conversion utilities to/from V8 native objects and NPVariant wrappers.
-    WEBKIT_EXPORT static void toNPVariant(v8::Local<v8::Value>, NPObject* root, NPVariant* result);
-    WEBKIT_EXPORT static v8::Handle<v8::Value> toV8Value(const NPVariant*);
+    BLINK_EXPORT static void toNPVariant(v8::Local<v8::Value>, NPObject* root, NPVariant* result);
+    BLINK_EXPORT static v8::Handle<v8::Value> toV8Value(const NPVariant*);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebBlob.h b/public/web/WebBlob.h
index 829df9a..490de0c 100644
--- a/public/web/WebBlob.h
+++ b/public/web/WebBlob.h
@@ -57,18 +57,18 @@
         return *this;
     }
 
-    WEBKIT_EXPORT static WebBlob createFromFile(const WebString& path, long long size);
-    WEBKIT_EXPORT static WebBlob fromV8Value(v8::Handle<v8::Value>);
+    BLINK_EXPORT static WebBlob createFromFile(const WebString& path, long long size);
+    BLINK_EXPORT static WebBlob fromV8Value(v8::Handle<v8::Value>);
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebBlob&);
-    WEBKIT_EXPORT WebURL url();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebBlob&);
+    BLINK_EXPORT WebURL url();
 
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT v8::Handle<v8::Value>  toV8Value();
+    BLINK_EXPORT v8::Handle<v8::Value>  toV8Value();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebBlob(const WTF::PassRefPtr<WebCore::Blob>&);
     WebBlob& operator=(const WTF::PassRefPtr<WebCore::Blob>&);
     operator WTF::PassRefPtr<WebCore::Blob>() const;
diff --git a/public/web/WebCache.h b/public/web/WebCache.h
index 3aecfa4..79a5219 100644
--- a/public/web/WebCache.h
+++ b/public/web/WebCache.h
@@ -67,20 +67,20 @@
     };
 
     // Sets the capacities of the resource cache, evicting objects as necessary.
-    WEBKIT_EXPORT static void setCapacities(size_t minDeadCapacity,
+    BLINK_EXPORT static void setCapacities(size_t minDeadCapacity,
                                             size_t maxDeadCapacity,
                                             size_t capacity);
 
     // Clears the cache (as much as possible; some resources may not be
     // cleared if they are actively referenced). Note that this method
     // only removes resources from live list, w/o releasing cache memory.
-    WEBKIT_EXPORT static void clear();
+    BLINK_EXPORT static void clear();
 
     // Gets the usage statistics from the resource cache.
-    WEBKIT_EXPORT static void getUsageStats(UsageStats*);
+    BLINK_EXPORT static void getUsageStats(UsageStats*);
 
     // Get usage stats about the resource cache.
-    WEBKIT_EXPORT static void getResourceTypeStats(ResourceTypeStats*);
+    BLINK_EXPORT static void getResourceTypeStats(ResourceTypeStats*);
 
 private:
     WebCache();  // Not intended to be instanced.
diff --git a/public/web/WebCachedURLRequest.h b/public/web/WebCachedURLRequest.h
index 0f2e55b..33b4690 100644
--- a/public/web/WebCachedURLRequest.h
+++ b/public/web/WebCachedURLRequest.h
@@ -46,14 +46,14 @@
 class WebCachedURLRequest {
 public:
     ~WebCachedURLRequest() { reset(); }
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
-    WEBKIT_EXPORT const WebURLRequest& urlRequest() const;
-    WEBKIT_EXPORT WebString charset() const;
-    WEBKIT_EXPORT bool forPreload() const;
-    WEBKIT_EXPORT WebString initiatorName() const;
+    BLINK_EXPORT const WebURLRequest& urlRequest() const;
+    BLINK_EXPORT WebString charset() const;
+    BLINK_EXPORT bool forPreload() const;
+    BLINK_EXPORT WebString initiatorName() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebCachedURLRequest(WebCore::FetchRequest*);
 #endif
 
diff --git a/public/web/WebColorName.h b/public/web/WebColorName.h
index 1f28d89..f719ff1 100644
--- a/public/web/WebColorName.h
+++ b/public/web/WebColorName.h
@@ -70,7 +70,7 @@
 };
 
 // Sets the values of a set of named colors.
-WEBKIT_EXPORT void setNamedColors(const WebColorName*, const WebColor*, size_t length);
+BLINK_EXPORT void setNamedColors(const WebColorName*, const WebColor*, size_t length);
 
 } // namespace WebKit
 
diff --git a/public/web/WebCrossOriginPreflightResultCache.h b/public/web/WebCrossOriginPreflightResultCache.h
index 3f80096..a75e855 100644
--- a/public/web/WebCrossOriginPreflightResultCache.h
+++ b/public/web/WebCrossOriginPreflightResultCache.h
@@ -39,7 +39,7 @@
 class WebCrossOriginPreflightResultCache {
 public:
     // Clears the cache.
-    WEBKIT_EXPORT static void clear();
+    BLINK_EXPORT static void clear();
 
 private:
     WebCrossOriginPreflightResultCache();  // Not intended to be instanced.
diff --git a/public/web/WebCustomElement.h b/public/web/WebCustomElement.h
index 06f4da4..757f4c6 100644
--- a/public/web/WebCustomElement.h
+++ b/public/web/WebCustomElement.h
@@ -44,7 +44,7 @@
     // own types for. Because Custom Element processing requires the
     // set of valid names to be known ahead of time, this method
     // should be called before an element with this name is created.
-    WEBKIT_EXPORT static void addEmbedderCustomElementName(const WebString& name);
+    BLINK_EXPORT static void addEmbedderCustomElementName(const WebString& name);
 
 private:
     WebCustomElement();
diff --git a/public/web/WebDOMActivityLogger.h b/public/web/WebDOMActivityLogger.h
index 2830b1d..f3507ae 100644
--- a/public/web/WebDOMActivityLogger.h
+++ b/public/web/WebDOMActivityLogger.h
@@ -33,6 +33,7 @@
 
 #include "../platform/WebCommon.h"
 #include "../platform/WebString.h"
+#include "../platform/WebURL.h"
 #include <v8.h>
 
 namespace WebKit {
@@ -41,15 +42,16 @@
 public:
     virtual ~WebDOMActivityLogger() { }
     virtual void log(const WebString& apiName, int argc, const v8::Handle<v8::Value>* argv, const WebString& extraInfo) { }
+    virtual void log(const WebString& apiName, int argc, const v8::Handle<v8::Value>* argv, const WebString& extraInfo, const WebURL& url, const WebString& title) { }
 };
 
 // Checks if a logger already exists for the world identified
 // by worldId (worldId may be 0 identifying the main world).
-WEBKIT_EXPORT bool hasDOMActivityLogger(int worldId);
+BLINK_EXPORT bool hasDOMActivityLogger(int worldId);
 
 // Checks if the provided logger is non-null and if so associates it
 // with the world identified by worldId (worldId may be 0 identifying the main world).
-WEBKIT_EXPORT void setDOMActivityLogger(int worldId, WebDOMActivityLogger*);
+BLINK_EXPORT void setDOMActivityLogger(int worldId, WebDOMActivityLogger*);
 
 } // namespace WebKit
 
diff --git a/public/web/WebDOMCustomEvent.h b/public/web/WebDOMCustomEvent.h
index 9165cf6..df211fd 100644
--- a/public/web/WebDOMCustomEvent.h
+++ b/public/web/WebDOMCustomEvent.h
@@ -41,7 +41,7 @@
 class WebDOMCustomEvent : public WebDOMEvent {
 public:
     WebDOMCustomEvent() { }
-    WEBKIT_EXPORT void initCustomEvent(const WebString& type, bool canBubble, bool cancelable, const WebSerializedScriptValue& messageData);
+    BLINK_EXPORT void initCustomEvent(const WebString& type, bool canBubble, bool cancelable, const WebSerializedScriptValue& messageData);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebDOMEvent.h b/public/web/WebDOMEvent.h
index 9e7e998..04a01c8 100644
--- a/public/web/WebDOMEvent.h
+++ b/public/web/WebDOMEvent.h
@@ -37,7 +37,7 @@
 #include "WebNode.h"
 
 namespace WebCore { class Event; }
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
 
@@ -61,38 +61,38 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebDOMEvent&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebDOMEvent&);
 
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString type() const;
-    WEBKIT_EXPORT WebNode target() const;
-    WEBKIT_EXPORT WebNode currentTarget() const;
+    BLINK_EXPORT WebString type() const;
+    BLINK_EXPORT WebNode target() const;
+    BLINK_EXPORT WebNode currentTarget() const;
 
-    WEBKIT_EXPORT PhaseType eventPhase() const;
-    WEBKIT_EXPORT bool bubbles() const;
-    WEBKIT_EXPORT bool cancelable() const;
+    BLINK_EXPORT PhaseType eventPhase() const;
+    BLINK_EXPORT bool bubbles() const;
+    BLINK_EXPORT bool cancelable() const;
 
-    WEBKIT_EXPORT bool isUIEvent() const;
-    WEBKIT_EXPORT bool isMouseEvent() const;
-    WEBKIT_EXPORT bool isMutationEvent() const;
-    WEBKIT_EXPORT bool isKeyboardEvent() const;
-    WEBKIT_EXPORT bool isTextEvent() const;
-    WEBKIT_EXPORT bool isCompositionEvent() const;
-    WEBKIT_EXPORT bool isDragEvent() const;
-    WEBKIT_EXPORT bool isClipboardEvent() const;
-    WEBKIT_EXPORT bool isMessageEvent() const;
-    WEBKIT_EXPORT bool isWheelEvent() const;
-    WEBKIT_EXPORT bool isBeforeTextInsertedEvent() const;
-    WEBKIT_EXPORT bool isOverflowEvent() const;
-    WEBKIT_EXPORT bool isPageTransitionEvent() const;
-    WEBKIT_EXPORT bool isPopStateEvent() const;
-    WEBKIT_EXPORT bool isProgressEvent() const;
-    WEBKIT_EXPORT bool isXMLHttpRequestProgressEvent() const;
-    WEBKIT_EXPORT bool isBeforeLoadEvent() const;
+    BLINK_EXPORT bool isUIEvent() const;
+    BLINK_EXPORT bool isMouseEvent() const;
+    BLINK_EXPORT bool isMutationEvent() const;
+    BLINK_EXPORT bool isKeyboardEvent() const;
+    BLINK_EXPORT bool isTextEvent() const;
+    BLINK_EXPORT bool isCompositionEvent() const;
+    BLINK_EXPORT bool isDragEvent() const;
+    BLINK_EXPORT bool isClipboardEvent() const;
+    BLINK_EXPORT bool isMessageEvent() const;
+    BLINK_EXPORT bool isWheelEvent() const;
+    BLINK_EXPORT bool isBeforeTextInsertedEvent() const;
+    BLINK_EXPORT bool isOverflowEvent() const;
+    BLINK_EXPORT bool isPageTransitionEvent() const;
+    BLINK_EXPORT bool isPopStateEvent() const;
+    BLINK_EXPORT bool isProgressEvent() const;
+    BLINK_EXPORT bool isXMLHttpRequestProgressEvent() const;
+    BLINK_EXPORT bool isBeforeLoadEvent() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebDOMEvent(const WTF::PassRefPtr<WebCore::Event>&);
     operator WTF::PassRefPtr<WebCore::Event>() const;
 #endif
@@ -113,7 +113,7 @@
 
 protected:
     typedef WebCore::Event WebDOMEventPrivate;
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     void assign(const WTF::PassRefPtr<WebDOMEventPrivate>&);
 
     template<typename T> T* unwrap()
diff --git a/public/web/WebDOMEventListener.h b/public/web/WebDOMEventListener.h
index 58992fe..6353be0 100644
--- a/public/web/WebDOMEventListener.h
+++ b/public/web/WebDOMEventListener.h
@@ -33,7 +33,7 @@
 
 #include "../platform/WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class EventTarget; }
 #endif
 
@@ -47,13 +47,13 @@
 
 class WebDOMEventListener {
 public:
-    WEBKIT_EXPORT WebDOMEventListener();
-    WEBKIT_EXPORT virtual ~WebDOMEventListener();
+    BLINK_EXPORT WebDOMEventListener();
+    BLINK_EXPORT virtual ~WebDOMEventListener();
 
     // Called when an event is received.
     virtual void handleEvent(const WebDOMEvent&) = 0;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     void notifyEventListenerDeleted(EventListenerWrapper*);
     EventListenerWrapper* createEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::EventTarget*);
     EventListenerWrapper* getEventListenerWrapper(const WebString& eventType, bool useCapture, WebCore::EventTarget*);
diff --git a/public/web/WebDOMMessageEvent.h b/public/web/WebDOMMessageEvent.h
index dace153..4f38338 100644
--- a/public/web/WebDOMMessageEvent.h
+++ b/public/web/WebDOMMessageEvent.h
@@ -34,9 +34,9 @@
 #include "WebDOMEvent.h"
 #include "WebSerializedScriptValue.h"
 
-#if WEBKIT_IMPLEMENTATION
-#include "core/dom/Event.h"
-#include "core/dom/MessageEvent.h"
+#if BLINK_IMPLEMENTATION
+#include "core/events/Event.h"
+#include "core/events/MessageEvent.h"
 #endif
 
 namespace WebKit {
@@ -47,12 +47,12 @@
 class WebDOMMessageEvent : public WebDOMEvent {
 public:
     WebDOMMessageEvent() { }
-    WEBKIT_EXPORT void initMessageEvent(const WebString& type, bool canBubble, bool cancelable, const WebSerializedScriptValue& messageData, const WebString& origin, const WebFrame* sourceFrame, const WebString& lastEventId);
+    BLINK_EXPORT void initMessageEvent(const WebString& type, bool canBubble, bool cancelable, const WebSerializedScriptValue& messageData, const WebString& origin, const WebFrame* sourceFrame, const WebString& lastEventId);
 
-    WEBKIT_EXPORT WebSerializedScriptValue data() const;
-    WEBKIT_EXPORT WebString origin() const;
+    BLINK_EXPORT WebSerializedScriptValue data() const;
+    BLINK_EXPORT WebString origin() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebDOMMessageEvent(const WTF::PassRefPtr<WebCore::MessageEvent>& e) : WebDOMEvent(e) { }
 #endif
 };
diff --git a/public/web/WebDOMMouseEvent.h b/public/web/WebDOMMouseEvent.h
index 373c9ee..dcfa89e 100644
--- a/public/web/WebDOMMouseEvent.h
+++ b/public/web/WebDOMMouseEvent.h
@@ -32,7 +32,7 @@
 
 #include "WebDOMEvent.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Event; }
 #endif
 
@@ -40,19 +40,19 @@
 
 class WebDOMMouseEvent : public WebDOMEvent {
 public:
-    WEBKIT_EXPORT int screenX() const;
-    WEBKIT_EXPORT int screenY() const;
-    WEBKIT_EXPORT int clientX() const;
-    WEBKIT_EXPORT int clientY() const;
-    WEBKIT_EXPORT int offsetX();
-    WEBKIT_EXPORT int offsetY();
-    WEBKIT_EXPORT int pageX() const;
-    WEBKIT_EXPORT int pageY() const;
-    WEBKIT_EXPORT int x() const;
-    WEBKIT_EXPORT int y() const;
+    BLINK_EXPORT int screenX() const;
+    BLINK_EXPORT int screenY() const;
+    BLINK_EXPORT int clientX() const;
+    BLINK_EXPORT int clientY() const;
+    BLINK_EXPORT int offsetX();
+    BLINK_EXPORT int offsetY();
+    BLINK_EXPORT int pageX() const;
+    BLINK_EXPORT int pageY() const;
+    BLINK_EXPORT int x() const;
+    BLINK_EXPORT int y() const;
 
-    WEBKIT_EXPORT int button() const;
-    WEBKIT_EXPORT bool buttonDown() const;
+    BLINK_EXPORT int button() const;
+    BLINK_EXPORT bool buttonDown() const;
 };
 
 } // namespace WebKit
diff --git a/public/web/WebDOMMutationEvent.h b/public/web/WebDOMMutationEvent.h
index 8eb3b12..921f101 100644
--- a/public/web/WebDOMMutationEvent.h
+++ b/public/web/WebDOMMutationEvent.h
@@ -32,7 +32,7 @@
 
 #include "WebDOMEvent.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Event; }
 #endif
 
@@ -46,11 +46,11 @@
         Removal         = 3
     };
 
-    WEBKIT_EXPORT WebNode relatedNode() const;
-    WEBKIT_EXPORT WebString prevValue() const;
-    WEBKIT_EXPORT WebString newValue() const;
-    WEBKIT_EXPORT WebString attrName() const;
-    WEBKIT_EXPORT AttrChangeType attrChange() const;
+    BLINK_EXPORT WebNode relatedNode() const;
+    BLINK_EXPORT WebString prevValue() const;
+    BLINK_EXPORT WebString newValue() const;
+    BLINK_EXPORT WebString attrName() const;
+    BLINK_EXPORT AttrChangeType attrChange() const;
 };
 
 } // namespace WebKit
diff --git a/public/web/WebDOMProgressEvent.h b/public/web/WebDOMProgressEvent.h
index e9b0921..d8db155 100644
--- a/public/web/WebDOMProgressEvent.h
+++ b/public/web/WebDOMProgressEvent.h
@@ -40,7 +40,7 @@
 class WebDOMProgressEvent : public WebDOMEvent {
 public:
     WebDOMProgressEvent() { }
-    WEBKIT_EXPORT WebDOMProgressEvent(const WebString& type, bool lengthIsComputable, unsigned long long loaded, unsigned long long total);
+    BLINK_EXPORT WebDOMProgressEvent(const WebString& type, bool lengthIsComputable, unsigned long long loaded, unsigned long long total);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebDOMResourceProgressEvent.h b/public/web/WebDOMResourceProgressEvent.h
index b65d93c..548a5cf 100644
--- a/public/web/WebDOMResourceProgressEvent.h
+++ b/public/web/WebDOMResourceProgressEvent.h
@@ -40,7 +40,7 @@
 class WebDOMResourceProgressEvent : public WebDOMProgressEvent {
 public:
     WebDOMResourceProgressEvent() { }
-    WEBKIT_EXPORT WebDOMResourceProgressEvent(const WebString& type, bool lengthIsComputable, unsigned long long loaded, unsigned long long total, const WebString& url);
+    BLINK_EXPORT WebDOMResourceProgressEvent(const WebString& type, bool lengthIsComputable, unsigned long long loaded, unsigned long long total, const WebString& url);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebDatabase.h b/public/web/WebDatabase.h
index f05d6c6..6ad7554 100644
--- a/public/web/WebDatabase.h
+++ b/public/web/WebDatabase.h
@@ -43,26 +43,26 @@
 
 class WebDatabase {
 public:
-    WEBKIT_EXPORT WebString name() const;
-    WEBKIT_EXPORT WebString displayName() const;
-    WEBKIT_EXPORT unsigned long estimatedSize() const;
-    WEBKIT_EXPORT WebSecurityOrigin securityOrigin() const;
-    WEBKIT_EXPORT bool isSyncDatabase() const;
+    BLINK_EXPORT WebString name() const;
+    BLINK_EXPORT WebString displayName() const;
+    BLINK_EXPORT unsigned long estimatedSize() const;
+    BLINK_EXPORT WebSecurityOrigin securityOrigin() const;
+    BLINK_EXPORT bool isSyncDatabase() const;
 
-    WEBKIT_EXPORT static void setObserver(WebDatabaseObserver*);
-    WEBKIT_EXPORT static WebDatabaseObserver* observer();
+    BLINK_EXPORT static void setObserver(WebDatabaseObserver*);
+    BLINK_EXPORT static WebDatabaseObserver* observer();
 
-    WEBKIT_EXPORT static void updateDatabaseSize(
+    BLINK_EXPORT static void updateDatabaseSize(
         const WebString& originIdentifier, const WebString& name, long long size);
-    WEBKIT_EXPORT static void updateSpaceAvailable(
+    BLINK_EXPORT static void updateSpaceAvailable(
         const WebString& originIdentifier, long long spaceAvailable);
-    WEBKIT_EXPORT static void resetSpaceAvailable(
+    BLINK_EXPORT static void resetSpaceAvailable(
         const WebString& originIdentifier);
 
-    WEBKIT_EXPORT static void closeDatabaseImmediately(
+    BLINK_EXPORT static void closeDatabaseImmediately(
         const WebString& originIdentifier, const WebString& databaseName);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebDatabase(const WebCore::DatabaseBackendBase*);
 #endif
 
diff --git a/public/web/WebDevToolsAgent.h b/public/web/WebDevToolsAgent.h
index f70ca26..0e19e14 100644
--- a/public/web/WebDevToolsAgent.h
+++ b/public/web/WebDevToolsAgent.h
@@ -52,10 +52,10 @@
     virtual ~WebDevToolsAgent() {}
 
     // Returns WebKit WebInspector protocol version.
-    WEBKIT_EXPORT static WebString inspectorProtocolVersion();
+    BLINK_EXPORT static WebString inspectorProtocolVersion();
 
     // Returns true if and only if the given protocol version is supported by the WebKit Web Inspector.
-    WEBKIT_EXPORT static bool supportsInspectorProtocolVersion(const WebString& version);
+    BLINK_EXPORT static bool supportsInspectorProtocolVersion(const WebString& version);
 
     virtual void attach() = 0;
     virtual void reattach(const WebString& savedState) = 0;
@@ -84,9 +84,9 @@
         virtual WebString message() = 0;
     };
     // Asynchronously request debugger to pause immediately and run the command.
-    WEBKIT_EXPORT static void interruptAndDispatch(MessageDescriptor*);
-    WEBKIT_EXPORT static bool shouldInterruptForMessage(const WebString&);
-    WEBKIT_EXPORT static void processPendingMessages();
+    BLINK_EXPORT static void interruptAndDispatch(MessageDescriptor*);
+    BLINK_EXPORT static bool shouldInterruptForMessage(const WebString&);
+    BLINK_EXPORT static void processPendingMessages();
 
 };
 
diff --git a/public/web/WebDevToolsFrontend.h b/public/web/WebDevToolsFrontend.h
index 2194ee3..9c1c36d 100644
--- a/public/web/WebDevToolsFrontend.h
+++ b/public/web/WebDevToolsFrontend.h
@@ -43,7 +43,7 @@
 // direct and delegate Apis to the host.
 class WebDevToolsFrontend {
 public:
-    WEBKIT_EXPORT static WebDevToolsFrontend* create(WebView* view,
+    BLINK_EXPORT static WebDevToolsFrontend* create(WebView* view,
                                                      WebDevToolsFrontendClient* client,
                                                      const WebString& applicationLocale);
 
diff --git a/public/web/WebDeviceOrientation.h b/public/web/WebDeviceOrientation.h
index f56c032..919ab68 100644
--- a/public/web/WebDeviceOrientation.h
+++ b/public/web/WebDeviceOrientation.h
@@ -26,7 +26,7 @@
 #ifndef WebDeviceOrientation_h
 #define WebDeviceOrientation_h
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 namespace WebCore { class DeviceOrientationData; }
 #endif
@@ -85,7 +85,7 @@
     bool canProvideAbsolute() const {return m_canProvideAbsolute; }
     bool absolute() const { return m_absolute; }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebDeviceOrientation(const WebCore::DeviceOrientationData*);
     operator WTF::PassRefPtr<WebCore::DeviceOrientationData>() const;
 #endif
diff --git a/public/web/WebDeviceOrientationClientMock.h b/public/web/WebDeviceOrientationClientMock.h
index b2e34d3..4013542 100644
--- a/public/web/WebDeviceOrientationClientMock.h
+++ b/public/web/WebDeviceOrientationClientMock.h
@@ -36,7 +36,7 @@
 
 class WebDeviceOrientationClientMock : public WebDeviceOrientationClient {
 public:
-    WEBKIT_EXPORT static WebDeviceOrientationClientMock* create();
+    BLINK_EXPORT static WebDeviceOrientationClientMock* create();
     ~WebDeviceOrientationClientMock() { reset(); }
 
     virtual void setController(WebDeviceOrientationController*) OVERRIDE;
@@ -44,12 +44,12 @@
     virtual void stopUpdating() OVERRIDE;
     virtual WebDeviceOrientation lastOrientation() const OVERRIDE;
 
-    WEBKIT_EXPORT void setOrientation(WebDeviceOrientation&);
+    BLINK_EXPORT void setOrientation(WebDeviceOrientation&);
 
 private:
     WebDeviceOrientationClientMock() { initialize(); }
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
 
     WebPrivateOwnPtr<WebCore::DeviceOrientationClientMock> m_clientMock;
 };
diff --git a/public/web/WebDeviceOrientationController.h b/public/web/WebDeviceOrientationController.h
index 8e98422..ce885ba 100644
--- a/public/web/WebDeviceOrientationController.h
+++ b/public/web/WebDeviceOrientationController.h
@@ -41,9 +41,9 @@
     {
     }
 
-    WEBKIT_EXPORT void didChangeDeviceOrientation(const WebDeviceOrientation&);
+    BLINK_EXPORT void didChangeDeviceOrientation(const WebDeviceOrientation&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebCore::DeviceOrientationController* controller() const;
 #endif
 
diff --git a/public/web/WebDocument.h b/public/web/WebDocument.h
index f75a1e7..23d107c 100644
--- a/public/web/WebDocument.h
+++ b/public/web/WebDocument.h
@@ -38,7 +38,7 @@
 #include "WebNode.h"
 #include "WebSecurityOrigin.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore {
 class Document;
 class DocumentType;
@@ -80,65 +80,65 @@
     }
     void assign(const WebDocument& e) { WebNode::assign(e); }
 
-    WEBKIT_EXPORT WebURL url() const;
+    BLINK_EXPORT WebURL url() const;
     // Note: Security checks should use the securityOrigin(), not url().
-    WEBKIT_EXPORT WebSecurityOrigin securityOrigin() const;
+    BLINK_EXPORT WebSecurityOrigin securityOrigin() const;
 
-    WEBKIT_EXPORT WebString encoding() const;
-    WEBKIT_EXPORT WebString contentLanguage() const;
+    BLINK_EXPORT WebString encoding() const;
+    BLINK_EXPORT WebString contentLanguage() const;
 
     // The url of the OpenSearch Desription Document (if any).
-    WEBKIT_EXPORT WebURL openSearchDescriptionURL() const;
+    BLINK_EXPORT WebURL openSearchDescriptionURL() const;
 
     // Returns the frame the document belongs to or 0 if the document is frameless.
-    WEBKIT_EXPORT WebFrame* frame() const;
-    WEBKIT_EXPORT bool isHTMLDocument() const;
-    WEBKIT_EXPORT bool isXHTMLDocument() const;
-    WEBKIT_EXPORT bool isPluginDocument() const;
-    WEBKIT_EXPORT WebURL baseURL() const;
+    BLINK_EXPORT WebFrame* frame() const;
+    BLINK_EXPORT bool isHTMLDocument() const;
+    BLINK_EXPORT bool isXHTMLDocument() const;
+    BLINK_EXPORT bool isPluginDocument() const;
+    BLINK_EXPORT WebURL baseURL() const;
 
     // The firstPartyForCookies is used to compute whether this document
     // appears in a "third-party" context for the purpose of third-party
     // cookie blocking.
-    WEBKIT_EXPORT WebURL firstPartyForCookies() const;
+    BLINK_EXPORT WebURL firstPartyForCookies() const;
 
-    WEBKIT_EXPORT WebElement documentElement() const;
-    WEBKIT_EXPORT WebElement body() const;
-    WEBKIT_EXPORT WebElement head();
-    WEBKIT_EXPORT WebString title() const;
-    WEBKIT_EXPORT WebNodeCollection all();
-    WEBKIT_EXPORT void forms(WebVector<WebFormElement>&) const;
-    WEBKIT_EXPORT void images(WebVector<WebElement>&);
-    WEBKIT_EXPORT WebURL completeURL(const WebString&) const;
-    WEBKIT_EXPORT WebElement getElementById(const WebString&) const;
-    WEBKIT_EXPORT WebNode focusedNode() const;
-    WEBKIT_EXPORT WebDocumentType doctype() const;
-    WEBKIT_EXPORT void cancelFullScreen();
-    WEBKIT_EXPORT WebElement fullScreenElement() const;
-    WEBKIT_EXPORT WebDOMEvent createEvent(const WebString& eventType);
-    WEBKIT_EXPORT WebReferrerPolicy referrerPolicy() const;
-    WEBKIT_EXPORT WebElement createElement(const WebString& tagName);
+    BLINK_EXPORT WebElement documentElement() const;
+    BLINK_EXPORT WebElement body() const;
+    BLINK_EXPORT WebElement head();
+    BLINK_EXPORT WebString title() const;
+    BLINK_EXPORT WebNodeCollection all();
+    BLINK_EXPORT void forms(WebVector<WebFormElement>&) const;
+    BLINK_EXPORT void images(WebVector<WebElement>&);
+    BLINK_EXPORT WebURL completeURL(const WebString&) const;
+    BLINK_EXPORT WebElement getElementById(const WebString&) const;
+    BLINK_EXPORT WebNode focusedNode() const;
+    BLINK_EXPORT WebDocumentType doctype() const;
+    BLINK_EXPORT void cancelFullScreen();
+    BLINK_EXPORT WebElement fullScreenElement() const;
+    BLINK_EXPORT WebDOMEvent createEvent(const WebString& eventType);
+    BLINK_EXPORT WebReferrerPolicy referrerPolicy() const;
+    BLINK_EXPORT WebElement createElement(const WebString& tagName);
 
     // Accessibility support. These methods should only be called on the
     // top-level document, because one accessibility cache spans all of
     // the documents on the page.
 
     // Gets the accessibility object for this document.
-    WEBKIT_EXPORT WebAXObject accessibilityObject() const;
+    BLINK_EXPORT WebAXObject accessibilityObject() const;
 
     // Gets the accessibility object for an object on this page by ID.
-    WEBKIT_EXPORT WebAXObject accessibilityObjectFromID(int axID) const;
+    BLINK_EXPORT WebAXObject accessibilityObjectFromID(int axID) const;
     // Inserts the given CSS source code as a user stylesheet in the document.
     // Meant for programatic/one-off injection, as opposed to
     // WebView::addUserStyleSheet which inserts styles for the lifetime of the
     // WebView.
-    WEBKIT_EXPORT void insertUserStyleSheet(const WebString& sourceCode, UserStyleLevel);
+    BLINK_EXPORT void insertUserStyleSheet(const WebString& sourceCode, UserStyleLevel);
 
-    WEBKIT_EXPORT WebVector<WebDraggableRegion> draggableRegions() const;
+    BLINK_EXPORT WebVector<WebDraggableRegion> draggableRegions() const;
 
-    WEBKIT_EXPORT v8::Handle<v8::Value> registerEmbedderCustomElement(const WebString& name, v8::Handle<v8::Value> options, WebExceptionCode&);
+    BLINK_EXPORT v8::Handle<v8::Value> registerEmbedderCustomElement(const WebString& name, v8::Handle<v8::Value> options, WebExceptionCode&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebDocument(const WTF::PassRefPtr<WebCore::Document>&);
     WebDocument& operator=(const WTF::PassRefPtr<WebCore::Document>&);
     operator WTF::PassRefPtr<WebCore::Document>() const;
diff --git a/public/web/WebDocumentType.h b/public/web/WebDocumentType.h
index a9113bb..5b5372a 100644
--- a/public/web/WebDocumentType.h
+++ b/public/web/WebDocumentType.h
@@ -33,7 +33,7 @@
 
 #include "WebNode.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class DocumentType; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -54,9 +54,9 @@
     }
     void assign(const WebDocumentType& e) { WebNode::assign(e); }
 
-    WEBKIT_EXPORT WebString name() const;
+    BLINK_EXPORT WebString name() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebDocumentType(const WTF::PassRefPtr<WebCore::DocumentType>&);
     WebDocumentType& operator=(const WTF::PassRefPtr<WebCore::DocumentType>&);
     operator WTF::PassRefPtr<WebCore::DocumentType>() const;
diff --git a/public/web/WebElement.h b/public/web/WebElement.h
index 618e3a5..8e37ec4 100644
--- a/public/web/WebElement.h
+++ b/public/web/WebElement.h
@@ -34,7 +34,7 @@
 #include "../platform/WebImage.h"
 #include "WebNode.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Element; }
 #endif
 
@@ -50,46 +50,46 @@
         WebElement& operator=(const WebElement& e) { WebNode::assign(e); return *this; }
         void assign(const WebElement& e) { WebNode::assign(e); }
 
-        WEBKIT_EXPORT bool isFormControlElement() const;
-        WEBKIT_EXPORT bool isTextFormControlElement() const;
+        BLINK_EXPORT bool isFormControlElement() const;
+        BLINK_EXPORT bool isTextFormControlElement() const;
         // Returns the qualified name, which may contain a prefix and a colon.
-        WEBKIT_EXPORT WebString tagName() const;
+        BLINK_EXPORT WebString tagName() const;
         // Check if this element has the specified qualified name. This function
         // doesn't makes much sense because we have no ways to check namespace
         // URI. Do not use this.
-        WEBKIT_EXPORT bool hasTagName(const WebString&) const;
+        BLINK_EXPORT bool hasTagName(const WebString&) const;
         // Check if this element has the specified local tag name, and the HTML
         // namespace. Tag name matching is case-insensitive.
-        WEBKIT_EXPORT bool hasHTMLTagName(const WebString&) const;
-        WEBKIT_EXPORT bool hasAttribute(const WebString&) const;
-        WEBKIT_EXPORT void removeAttribute(const WebString&);
-        WEBKIT_EXPORT WebString getAttribute(const WebString&) const;
-        WEBKIT_EXPORT bool setAttribute(const WebString& name, const WebString& value);
-        WEBKIT_EXPORT WebString innerText();
-        WEBKIT_EXPORT WebDocument document() const;
-        WEBKIT_EXPORT void requestFullScreen();
-        WEBKIT_EXPORT WebString attributeLocalName(unsigned index) const;
-        WEBKIT_EXPORT WebString attributeValue(unsigned index) const;
-        WEBKIT_EXPORT unsigned attributeCount() const;
-        WEBKIT_EXPORT WebNode shadowRoot() const;
+        BLINK_EXPORT bool hasHTMLTagName(const WebString&) const;
+        BLINK_EXPORT bool hasAttribute(const WebString&) const;
+        BLINK_EXPORT void removeAttribute(const WebString&);
+        BLINK_EXPORT WebString getAttribute(const WebString&) const;
+        BLINK_EXPORT bool setAttribute(const WebString& name, const WebString& value);
+        BLINK_EXPORT WebString innerText();
+        BLINK_EXPORT WebDocument document() const;
+        BLINK_EXPORT void requestFullScreen();
+        BLINK_EXPORT WebString attributeLocalName(unsigned index) const;
+        BLINK_EXPORT WebString attributeValue(unsigned index) const;
+        BLINK_EXPORT unsigned attributeCount() const;
+        BLINK_EXPORT WebNode shadowRoot() const;
 
         // Returns the language code specified for this element.  This attribute
         // is inherited, so the returned value is drawn from the closest parent
         // element that has the lang attribute set, or from the HTTP
         // "Content-Language" header as a fallback.
-        WEBKIT_EXPORT WebString computeInheritedLanguage() const;
+        BLINK_EXPORT WebString computeInheritedLanguage() const;
 
         // Returns the bounds of the element in viewport space. The bounds
         // have been adjusted to include any transformations. This view is
         // also called the Root View in WebKit.
         // This function will update the layout if required.
-        WEBKIT_EXPORT WebRect boundsInViewportSpace();
+        BLINK_EXPORT WebRect boundsInViewportSpace();
 
         // Returns the image contents of this element or a null WebImage
         // if there isn't any.
-        WEBKIT_EXPORT WebImage imageContents();
+        BLINK_EXPORT WebImage imageContents();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
         WebElement(const WTF::PassRefPtr<WebCore::Element>&);
         WebElement& operator=(const WTF::PassRefPtr<WebCore::Element>&);
         operator WTF::PassRefPtr<WebCore::Element>() const;
diff --git a/public/web/WebFont.h b/public/web/WebFont.h
index 5d2d1a4..27dc3e0 100644
--- a/public/web/WebFont.h
+++ b/public/web/WebFont.h
@@ -48,7 +48,7 @@
 public:
     virtual ~WebFont() { }
 
-    WEBKIT_EXPORT static WebFont* create(const WebFontDescription&);
+    BLINK_EXPORT static WebFont* create(const WebFontDescription&);
 
     virtual WebFontDescription fontDescription() const = 0;
 
diff --git a/public/web/WebFontCache.h b/public/web/WebFontCache.h
index 0a46236..90c56ba 100644
--- a/public/web/WebFontCache.h
+++ b/public/web/WebFontCache.h
@@ -39,16 +39,16 @@
 class WebFontCache {
 public:
     // Returns the number of items in the font data cache.
-    WEBKIT_EXPORT static size_t fontDataCount();
+    BLINK_EXPORT static size_t fontDataCount();
 
     // Returns the number of inactive items in the font data cache.
-    WEBKIT_EXPORT static size_t inactiveFontDataCount();
+    BLINK_EXPORT static size_t inactiveFontDataCount();
 
     // Clears the cache.
-    WEBKIT_EXPORT static void clear();
+    BLINK_EXPORT static void clear();
 
     // Purges inactive font data.
-    WEBKIT_EXPORT static void prune();
+    BLINK_EXPORT static void prune();
 
 private:
     WebFontCache();  // Not intended to be instanced.
diff --git a/public/web/WebFontDescription.h b/public/web/WebFontDescription.h
index 4ef5b7f..465a4d5 100644
--- a/public/web/WebFontDescription.h
+++ b/public/web/WebFontDescription.h
@@ -33,7 +33,7 @@
 
 #include "../platform/WebString.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class FontDescription; }
 #endif
 
@@ -94,7 +94,7 @@
     short letterSpacing;
     short wordSpacing;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFontDescription(const WebCore::FontDescription&, short fontLetterSpacing, short fontWordSpacing);
 
     operator WebCore::FontDescription() const;
diff --git a/public/web/WebFormControlElement.h b/public/web/WebFormControlElement.h
index 1be6610..a70d365 100644
--- a/public/web/WebFormControlElement.h
+++ b/public/web/WebFormControlElement.h
@@ -35,7 +35,7 @@
 #include "WebElement.h"
 #include "WebFormElement.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class HTMLFormControlElement; }
 #endif
 
@@ -54,21 +54,21 @@
     }
     void assign(const WebFormControlElement& e) { WebElement::assign(e); }
 
-    WEBKIT_EXPORT bool isEnabled() const;
-    WEBKIT_EXPORT bool isReadOnly() const;
-    WEBKIT_EXPORT WebString formControlName() const;
-    WEBKIT_EXPORT WebString formControlType() const;
+    BLINK_EXPORT bool isEnabled() const;
+    BLINK_EXPORT bool isReadOnly() const;
+    BLINK_EXPORT WebString formControlName() const;
+    BLINK_EXPORT WebString formControlType() const;
 
-    WEBKIT_EXPORT void dispatchFormControlChangeEvent();
+    BLINK_EXPORT void dispatchFormControlChangeEvent();
 
     // Returns the name that should be used for the specified |element| when
     // storing autofill data.  This is either the field name or its id, an empty
     // string if it has no name and no id.
-    WEBKIT_EXPORT WebString nameForAutofill() const;
+    BLINK_EXPORT WebString nameForAutofill() const;
 
-    WEBKIT_EXPORT WebFormElement form() const;
+    BLINK_EXPORT WebFormElement form() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebFormControlElement(const WTF::PassRefPtr<WebCore::HTMLFormControlElement>&);
     WebFormControlElement& operator=(const WTF::PassRefPtr<WebCore::HTMLFormControlElement>&);
     operator WTF::PassRefPtr<WebCore::HTMLFormControlElement>() const;
diff --git a/public/web/WebFormElement.h b/public/web/WebFormElement.h
index c3d3073..aa30f9d 100644
--- a/public/web/WebFormElement.h
+++ b/public/web/WebFormElement.h
@@ -34,7 +34,7 @@
 #include "../platform/WebVector.h"
 #include "WebElement.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class HTMLFormElement; }
 #endif
 
@@ -59,16 +59,16 @@
         }
         void assign(const WebFormElement& element) { WebElement::assign(element); }
 
-        WEBKIT_EXPORT bool autoComplete() const;
-        WEBKIT_EXPORT WebString action() const;
-        WEBKIT_EXPORT WebString name() const;
-        WEBKIT_EXPORT WebString method() const;
-        WEBKIT_EXPORT bool wasUserSubmitted() const;
-        WEBKIT_EXPORT void submit();
+        BLINK_EXPORT bool autoComplete() const;
+        BLINK_EXPORT WebString action() const;
+        BLINK_EXPORT WebString name() const;
+        BLINK_EXPORT WebString method() const;
+        BLINK_EXPORT bool wasUserSubmitted() const;
+        BLINK_EXPORT void submit();
         // FIXME: Deprecate and replace with WebVector<WebElement>.
-        WEBKIT_EXPORT void getNamedElements(const WebString&, WebVector<WebNode>&);
-        WEBKIT_EXPORT void getFormControlElements(WebVector<WebFormControlElement>&) const;
-        WEBKIT_EXPORT bool checkValidityWithoutDispatchingEvents();
+        BLINK_EXPORT void getNamedElements(const WebString&, WebVector<WebNode>&);
+        BLINK_EXPORT void getFormControlElements(WebVector<WebFormControlElement>&) const;
+        BLINK_EXPORT bool checkValidityWithoutDispatchingEvents();
 
         enum AutocompleteResult {
             AutocompleteResultSuccess,
@@ -76,9 +76,9 @@
             AutocompleteResultErrorCancel,
             AutocompleteResultErrorInvalid,
         };
-        WEBKIT_EXPORT void finishRequestAutocomplete(WebFormElement::AutocompleteResult);
+        BLINK_EXPORT void finishRequestAutocomplete(WebFormElement::AutocompleteResult);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
         WebFormElement(const WTF::PassRefPtr<WebCore::HTMLFormElement>&);
         WebFormElement& operator=(const WTF::PassRefPtr<WebCore::HTMLFormElement>&);
         operator WTF::PassRefPtr<WebCore::HTMLFormElement>() const;
diff --git a/public/web/WebFrame.h b/public/web/WebFrame.h
index 211def6..3a7ce1f 100644
--- a/public/web/WebFrame.h
+++ b/public/web/WebFrame.h
@@ -93,21 +93,21 @@
     typedef unsigned RenderAsTextControls;
 
     // Returns the number of live WebFrame objects, used for leak checking.
-    WEBKIT_EXPORT static int instanceCount();
+    BLINK_EXPORT static int instanceCount();
 
     // Returns the WebFrame associated with the current V8 context. This
     // function can return 0 if the context is associated with a Document that
     // is not currently being displayed in a Frame.
-    WEBKIT_EXPORT static WebFrame* frameForCurrentContext();
+    BLINK_EXPORT static WebFrame* frameForCurrentContext();
 
     // Returns the frame corresponding to the given context. This can return 0
     // if the context is detached from the frame, or if the context doesn't
     // correspond to a frame (e.g., workers).
-    WEBKIT_EXPORT static WebFrame* frameForContext(v8::Handle<v8::Context>);
+    BLINK_EXPORT static WebFrame* frameForContext(v8::Handle<v8::Context>);
 
     // Returns the frame inside a given frame or iframe element. Returns 0 if
     // the given element is not a frame, iframe or if the frame is empty.
-    WEBKIT_EXPORT static WebFrame* fromFrameOwnerElement(const WebElement&);
+    BLINK_EXPORT static WebFrame* fromFrameOwnerElement(const WebElement&);
 
 
     // Basic properties ---------------------------------------------------
@@ -465,12 +465,8 @@
     // scaling option. If constrainToNode node is specified, then only the given node
     // is printed (for now only plugins are supported), instead of the entire frame.
     // Returns the number of pages that can be printed at the given
-    // page size. The out param useBrowserOverlays specifies whether the browser
-    // process should use its overlays (header, footer, margins etc) or whether
-    // the renderer controls this.
-    virtual int printBegin(const WebPrintParams&,
-                           const WebNode& constrainToNode = WebNode(),
-                           bool* useBrowserOverlays = 0) = 0;
+    // page size.
+    virtual int printBegin(const WebPrintParams&, const WebNode& constrainToNode = WebNode()) = 0;
 
     // Returns the page shrinking factor calculated by webkit (usually
     // between 1/1.25 and 1/2). Returns 0 if the page number is invalid or
diff --git a/public/web/WebFrameClient.h b/public/web/WebFrameClient.h
index b24af80..3385145 100644
--- a/public/web/WebFrameClient.h
+++ b/public/web/WebFrameClient.h
@@ -58,7 +58,7 @@
 class WebFrame;
 class WebMediaPlayer;
 class WebMediaPlayerClient;
-class WebNavigationControllerRegistry;
+class WebServiceWorkerRegistry;
 class WebNode;
 class WebPlugin;
 class WebRTCPeerConnectionHandler;
@@ -92,7 +92,7 @@
     // May return null.
     virtual WebApplicationCacheHost* createApplicationCacheHost(WebFrame*, WebApplicationCacheHostClient*) { return 0; }
 
-    virtual WebNavigationControllerRegistry* navigationControllerRegistry(WebFrame*) { return 0; }
+    virtual WebServiceWorkerRegistry* serviceWorkerRegistry(WebFrame*) { return 0; }
 
 
     // Services ------------------------------------------------------------
@@ -256,6 +256,9 @@
     // A PingLoader was created, and a request dispatched to a URL.
     virtual void didDispatchPingLoader(WebFrame*, const WebURL&) { }
 
+    // The loaders in this frame have been stopped.
+    virtual void didAbortLoading(WebFrame*) { }
+
     // Script notifications ------------------------------------------------
 
     // Script in the page tried to allocate too much memory.
diff --git a/public/web/WebGeolocationClientMock.h b/public/web/WebGeolocationClientMock.h
index 06d8b1d..8f0d63b 100644
--- a/public/web/WebGeolocationClientMock.h
+++ b/public/web/WebGeolocationClientMock.h
@@ -45,14 +45,14 @@
 
 class WebGeolocationClientMock : public WebGeolocationClient {
 public:
-    WEBKIT_EXPORT static WebGeolocationClientMock* create();
+    BLINK_EXPORT static WebGeolocationClientMock* create();
     ~WebGeolocationClientMock() { reset(); }
 
-    WEBKIT_EXPORT void setPosition(double latitude, double longitude, double accuracy);
-    WEBKIT_EXPORT void setPositionUnavailableError(const WebString& message);
-    WEBKIT_EXPORT void setPermission(bool);
-    WEBKIT_EXPORT int numberOfPendingPermissionRequests() const;
-    WEBKIT_EXPORT void resetMock();
+    BLINK_EXPORT void setPosition(double latitude, double longitude, double accuracy);
+    BLINK_EXPORT void setPositionUnavailableError(const WebString& message);
+    BLINK_EXPORT void setPermission(bool);
+    BLINK_EXPORT int numberOfPendingPermissionRequests() const;
+    BLINK_EXPORT void resetMock();
 
     virtual void startUpdating();
     virtual void stopUpdating();
@@ -68,7 +68,7 @@
 
 private:
     WebGeolocationClientMock();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
     WebPrivateOwnPtr<WebCore::GeolocationClientMock> m_clientMock;
 };
diff --git a/public/web/WebGeolocationController.h b/public/web/WebGeolocationController.h
index ea56c35..51a0766 100644
--- a/public/web/WebGeolocationController.h
+++ b/public/web/WebGeolocationController.h
@@ -40,10 +40,10 @@
 // WebGeolocationClient::geolocationDestroyed() has been received.
 class WebGeolocationController : public WebNonCopyable {
 public:
-    WEBKIT_EXPORT void positionChanged(const WebGeolocationPosition&);
-    WEBKIT_EXPORT void errorOccurred(const WebGeolocationError&);
+    BLINK_EXPORT void positionChanged(const WebGeolocationPosition&);
+    BLINK_EXPORT void errorOccurred(const WebGeolocationError&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebGeolocationController(WebCore::GeolocationController* c)
         : m_private(c)
     {
diff --git a/public/web/WebGeolocationError.h b/public/web/WebGeolocationError.h
index b309336..0ce55bc 100644
--- a/public/web/WebGeolocationError.h
+++ b/public/web/WebGeolocationError.h
@@ -29,7 +29,7 @@
 #include "../platform/WebCommon.h"
 #include "../platform/WebPrivatePtr.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/PassRefPtr.h"
 #endif
 
@@ -50,11 +50,11 @@
     WebGeolocationError(const WebGeolocationError& other) { assign(other); }
     ~WebGeolocationError() { reset(); }
 
-    WEBKIT_EXPORT void assign(Error code, const WebString& message);
-    WEBKIT_EXPORT void assign(const WebGeolocationError&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(Error code, const WebString& message);
+    BLINK_EXPORT void assign(const WebGeolocationError&);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebGeolocationError(WTF::PassRefPtr<WebCore::GeolocationError>);
     WebGeolocationError& operator=(WTF::PassRefPtr<WebCore::GeolocationError>);
     operator WTF::PassRefPtr<WebCore::GeolocationError>() const;
diff --git a/public/web/WebGeolocationPermissionRequest.h b/public/web/WebGeolocationPermissionRequest.h
index e689a86..1f4a9f8 100644
--- a/public/web/WebGeolocationPermissionRequest.h
+++ b/public/web/WebGeolocationPermissionRequest.h
@@ -43,10 +43,10 @@
 // WebGeolocationClient::cancelPermissionRequest (request cancelled).
 class WebGeolocationPermissionRequest {
 public:
-    WEBKIT_EXPORT WebSecurityOrigin securityOrigin() const;
-    WEBKIT_EXPORT void setIsAllowed(bool);
+    BLINK_EXPORT WebSecurityOrigin securityOrigin() const;
+    BLINK_EXPORT void setIsAllowed(bool);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebGeolocationPermissionRequest(WebCore::Geolocation* geolocation)
         : m_private(geolocation)
     {
diff --git a/public/web/WebGeolocationPermissionRequestManager.h b/public/web/WebGeolocationPermissionRequestManager.h
index 4291e24..ff62032 100644
--- a/public/web/WebGeolocationPermissionRequestManager.h
+++ b/public/web/WebGeolocationPermissionRequestManager.h
@@ -45,13 +45,13 @@
     WebGeolocationPermissionRequestManager() { init(); }
     ~WebGeolocationPermissionRequestManager() { reset(); }
 
-    WEBKIT_EXPORT int add(const WebKit::WebGeolocationPermissionRequest&);
-    WEBKIT_EXPORT bool remove(const WebKit::WebGeolocationPermissionRequest&, int&);
-    WEBKIT_EXPORT bool remove(int, WebKit::WebGeolocationPermissionRequest&);
+    BLINK_EXPORT int add(const WebKit::WebGeolocationPermissionRequest&);
+    BLINK_EXPORT bool remove(const WebKit::WebGeolocationPermissionRequest&, int&);
+    BLINK_EXPORT bool remove(int, WebKit::WebGeolocationPermissionRequest&);
 
 private:
-    WEBKIT_EXPORT void init();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void init();
+    BLINK_EXPORT void reset();
 
     WebPrivateOwnPtr<WebGeolocationPermissionRequestManagerPrivate> m_private;
     int m_lastId;
diff --git a/public/web/WebGeolocationPosition.h b/public/web/WebGeolocationPosition.h
index 26efbbe..9ccdbcd 100644
--- a/public/web/WebGeolocationPosition.h
+++ b/public/web/WebGeolocationPosition.h
@@ -29,7 +29,7 @@
 #include "../platform/WebCommon.h"
 #include "../platform/WebPrivatePtr.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "wtf/PassRefPtr.h"
 #endif
 
@@ -47,11 +47,11 @@
     WebGeolocationPosition(const WebGeolocationPosition& other) { assign(other); }
     ~WebGeolocationPosition() { reset(); }
 
-    WEBKIT_EXPORT void assign(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed);
-    WEBKIT_EXPORT void assign(const WebGeolocationPosition&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(double timestamp, double latitude, double longitude, double accuracy, bool providesAltitude, double altitude, bool providesAltitudeAccuracy, double altitudeAccuracy, bool providesHeading, double heading, bool providesSpeed, double speed);
+    BLINK_EXPORT void assign(const WebGeolocationPosition&);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebGeolocationPosition(WTF::PassRefPtr<WebCore::GeolocationPosition>);
     WebGeolocationPosition& operator=(WTF::PassRefPtr<WebCore::GeolocationPosition>);
     operator WTF::PassRefPtr<WebCore::GeolocationPosition>() const;
diff --git a/public/web/WebGlyphCache.h b/public/web/WebGlyphCache.h
index a417077..ec32290 100644
--- a/public/web/WebGlyphCache.h
+++ b/public/web/WebGlyphCache.h
@@ -40,7 +40,7 @@
 class WebGlyphCache {
 public:
     // Returns the number of pages in the glyph cache.
-    WEBKIT_EXPORT static size_t pageCount();
+    BLINK_EXPORT static size_t pageCount();
 
 private:
     WebGlyphCache();  // Not intended to be instanced.
diff --git a/public/web/WebHelperPlugin.h b/public/web/WebHelperPlugin.h
index b10ffa5..9b96313 100644
--- a/public/web/WebHelperPlugin.h
+++ b/public/web/WebHelperPlugin.h
@@ -42,7 +42,7 @@
 
 class WebHelperPlugin : public WebWidget {
 public:
-    WEBKIT_EXPORT static WebHelperPlugin* create(WebWidgetClient*);
+    BLINK_EXPORT static WebHelperPlugin* create(WebWidgetClient*);
 
     virtual void initializeFrame(WebFrameClient*) = 0;
 
diff --git a/public/web/WebHistoryItem.h b/public/web/WebHistoryItem.h
index e3d198a..51500ba 100644
--- a/public/web/WebHistoryItem.h
+++ b/public/web/WebHistoryItem.h
@@ -60,73 +60,73 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebHistoryItem&);
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebHistoryItem&);
 
     bool isNull() const { return m_private.isNull(); }
 
-    WEBKIT_EXPORT WebString urlString() const;
-    WEBKIT_EXPORT void setURLString(const WebString&);
+    BLINK_EXPORT WebString urlString() const;
+    BLINK_EXPORT void setURLString(const WebString&);
 
-    WEBKIT_EXPORT WebString originalURLString() const;
-    WEBKIT_EXPORT void setOriginalURLString(const WebString&);
+    BLINK_EXPORT WebString originalURLString() const;
+    BLINK_EXPORT void setOriginalURLString(const WebString&);
 
-    WEBKIT_EXPORT WebString referrer() const;
-    WEBKIT_EXPORT void setReferrer(const WebString&);
+    BLINK_EXPORT WebString referrer() const;
+    BLINK_EXPORT void setReferrer(const WebString&);
 
-    WEBKIT_EXPORT WebString target() const;
-    WEBKIT_EXPORT void setTarget(const WebString&);
+    BLINK_EXPORT WebString target() const;
+    BLINK_EXPORT void setTarget(const WebString&);
 
-    WEBKIT_EXPORT WebString parent() const;
-    WEBKIT_EXPORT void setParent(const WebString&);
+    BLINK_EXPORT WebString parent() const;
+    BLINK_EXPORT void setParent(const WebString&);
 
-    WEBKIT_EXPORT WebString title() const;
-    WEBKIT_EXPORT void setTitle(const WebString&);
+    BLINK_EXPORT WebString title() const;
+    BLINK_EXPORT void setTitle(const WebString&);
 
-    WEBKIT_EXPORT WebString alternateTitle() const;
-    WEBKIT_EXPORT void setAlternateTitle(const WebString&);
+    BLINK_EXPORT WebString alternateTitle() const;
+    BLINK_EXPORT void setAlternateTitle(const WebString&);
 
-    WEBKIT_EXPORT double lastVisitedTime() const;
-    WEBKIT_EXPORT void setLastVisitedTime(double);
+    BLINK_EXPORT double lastVisitedTime() const;
+    BLINK_EXPORT void setLastVisitedTime(double);
 
-    WEBKIT_EXPORT WebPoint scrollOffset() const;
-    WEBKIT_EXPORT void setScrollOffset(const WebPoint&);
+    BLINK_EXPORT WebPoint scrollOffset() const;
+    BLINK_EXPORT void setScrollOffset(const WebPoint&);
 
-    WEBKIT_EXPORT float pageScaleFactor() const;
-    WEBKIT_EXPORT void setPageScaleFactor(float);
+    BLINK_EXPORT float pageScaleFactor() const;
+    BLINK_EXPORT void setPageScaleFactor(float);
 
-    WEBKIT_EXPORT bool isTargetItem() const;
-    WEBKIT_EXPORT void setIsTargetItem(bool);
+    BLINK_EXPORT bool isTargetItem() const;
+    BLINK_EXPORT void setIsTargetItem(bool);
 
-    WEBKIT_EXPORT int visitCount() const;
-    WEBKIT_EXPORT void setVisitCount(int);
+    BLINK_EXPORT int visitCount() const;
+    BLINK_EXPORT void setVisitCount(int);
 
-    WEBKIT_EXPORT WebVector<WebString> documentState() const;
-    WEBKIT_EXPORT void setDocumentState(const WebVector<WebString>&);
+    BLINK_EXPORT WebVector<WebString> documentState() const;
+    BLINK_EXPORT void setDocumentState(const WebVector<WebString>&);
 
-    WEBKIT_EXPORT long long itemSequenceNumber() const;
-    WEBKIT_EXPORT void setItemSequenceNumber(long long);
+    BLINK_EXPORT long long itemSequenceNumber() const;
+    BLINK_EXPORT void setItemSequenceNumber(long long);
 
-    WEBKIT_EXPORT long long documentSequenceNumber() const;
-    WEBKIT_EXPORT void setDocumentSequenceNumber(long long);
+    BLINK_EXPORT long long documentSequenceNumber() const;
+    BLINK_EXPORT void setDocumentSequenceNumber(long long);
 
-    WEBKIT_EXPORT WebSerializedScriptValue stateObject() const;
-    WEBKIT_EXPORT void setStateObject(const WebSerializedScriptValue&);
+    BLINK_EXPORT WebSerializedScriptValue stateObject() const;
+    BLINK_EXPORT void setStateObject(const WebSerializedScriptValue&);
 
-    WEBKIT_EXPORT WebString httpContentType() const;
-    WEBKIT_EXPORT void setHTTPContentType(const WebString&);
+    BLINK_EXPORT WebString httpContentType() const;
+    BLINK_EXPORT void setHTTPContentType(const WebString&);
 
-    WEBKIT_EXPORT WebHTTPBody httpBody() const;
-    WEBKIT_EXPORT void setHTTPBody(const WebHTTPBody&);
+    BLINK_EXPORT WebHTTPBody httpBody() const;
+    BLINK_EXPORT void setHTTPBody(const WebHTTPBody&);
 
-    WEBKIT_EXPORT WebVector<WebHistoryItem> children() const;
-    WEBKIT_EXPORT void setChildren(const WebVector<WebHistoryItem>&);
-    WEBKIT_EXPORT void appendToChildren(const WebHistoryItem&);
+    BLINK_EXPORT WebVector<WebHistoryItem> children() const;
+    BLINK_EXPORT void setChildren(const WebVector<WebHistoryItem>&);
+    BLINK_EXPORT void appendToChildren(const WebHistoryItem&);
 
-    WEBKIT_EXPORT WebVector<WebString> getReferencedFilePaths() const;
+    BLINK_EXPORT WebVector<WebString> getReferencedFilePaths() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebHistoryItem(const WTF::PassRefPtr<WebCore::HistoryItem>&);
     WebHistoryItem& operator=(const WTF::PassRefPtr<WebCore::HistoryItem>&);
     operator WTF::PassRefPtr<WebCore::HistoryItem>() const;
diff --git a/public/web/WebHitTestResult.h b/public/web/WebHitTestResult.h
index b129aad..568a738 100644
--- a/public/web/WebHitTestResult.h
+++ b/public/web/WebHitTestResult.h
@@ -48,30 +48,30 @@
     WebHitTestResult(const WebHitTestResult& info) { assign(info); }
     ~WebHitTestResult() { reset(); }
 
-    WEBKIT_EXPORT void assign(const WebHitTestResult&);
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT bool isNull() const;
+    BLINK_EXPORT void assign(const WebHitTestResult&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT bool isNull() const;
 
     // The node that was hit (only one for point-based tests).
-    WEBKIT_EXPORT WebNode node() const;
+    BLINK_EXPORT WebNode node() const;
 
     // Coordinates of the point that was hit. Relative to the node.
-    WEBKIT_EXPORT WebPoint localPoint() const;
+    BLINK_EXPORT WebPoint localPoint() const;
 
     // If a link (eg. anchor or area tag) is hit, return the element.
     // Return null otheriwse.
-    WEBKIT_EXPORT WebElement urlElement() const;
+    BLINK_EXPORT WebElement urlElement() const;
 
     // If an image is hit, return the image source. Return empty otherwise.
-    WEBKIT_EXPORT WebURL absoluteImageURL() const;
+    BLINK_EXPORT WebURL absoluteImageURL() const;
 
     // If an link is hit, return the link url source. Return empty otherwise.
-    WEBKIT_EXPORT WebURL absoluteLinkURL() const;
+    BLINK_EXPORT WebURL absoluteLinkURL() const;
 
     // Return whether an editable input element was hit.
-    WEBKIT_EXPORT bool isContentEditable() const;
+    BLINK_EXPORT bool isContentEditable() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebHitTestResult(const WebCore::HitTestResult&);
     WebHitTestResult& operator=(const WebCore::HitTestResult&);
     operator WebCore::HitTestResult() const;
diff --git a/public/web/WebIconURL.h b/public/web/WebIconURL.h
index e718372..8be121e 100644
--- a/public/web/WebIconURL.h
+++ b/public/web/WebIconURL.h
@@ -31,7 +31,7 @@
 #ifndef WebIconURL_h
 #define WebIconURL_h
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/dom/IconURL.h"
 #endif
 #include "../platform/WebURL.h"
@@ -68,7 +68,7 @@
         return m_iconURL;
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebIconURL(const WebCore::IconURL& iconURL)
         : m_iconType(static_cast<Type>(iconURL.m_iconType))
         , m_iconURL(iconURL.m_iconURL)
diff --git a/public/web/WebImageCache.h b/public/web/WebImageCache.h
index b766488..d2521b2 100644
--- a/public/web/WebImageCache.h
+++ b/public/web/WebImageCache.h
@@ -45,17 +45,17 @@
 class WebImageCache {
 public:
     // Sets the capacities of the image cache, evicting objects as necessary.
-    WEBKIT_EXPORT static void setCacheLimitInBytes(size_t);
+    BLINK_EXPORT static void setCacheLimitInBytes(size_t);
 
     // Clears the cache (as much as possible; some resources may not be
     // cleared if they are actively referenced).
-    WEBKIT_EXPORT static void clear();
+    BLINK_EXPORT static void clear();
 
     // Returns the number of bytes used by the cache.
-    WEBKIT_EXPORT static size_t memoryUsageInBytes();
+    BLINK_EXPORT static size_t memoryUsageInBytes();
 
     // Returns the number of cached entries.
-    WEBKIT_EXPORT static unsigned cacheEntries();
+    BLINK_EXPORT static unsigned cacheEntries();
 
 private:
     WebImageCache();  // Not intended to be instanced.
diff --git a/public/web/WebImageDecoder.h b/public/web/WebImageDecoder.h
index 309220e..e4deb30 100644
--- a/public/web/WebImageDecoder.h
+++ b/public/web/WebImageDecoder.h
@@ -55,32 +55,32 @@
 
     // Sets data contents for underlying decoder. All the API methods
     // require that setData() is called prior to their use.
-    WEBKIT_EXPORT void setData(const WebData& data, bool allDataReceived);
+    BLINK_EXPORT void setData(const WebData& data, bool allDataReceived);
 
     // Deletes owned decoder.
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
     // Returns true if image decoding failed.
-    WEBKIT_EXPORT bool isFailed() const;
+    BLINK_EXPORT bool isFailed() const;
 
     // Returns true if size information is available for the decoder.
-    WEBKIT_EXPORT bool isSizeAvailable() const;
+    BLINK_EXPORT bool isSizeAvailable() const;
 
     // Returns the size of the image.
-    WEBKIT_EXPORT WebSize size() const;
+    BLINK_EXPORT WebSize size() const;
 
     // Gives frame count for the image. For multiple frames, decoder scans the image data for the count.
-    WEBKIT_EXPORT size_t frameCount() const;
+    BLINK_EXPORT size_t frameCount() const;
 
     // Returns if the frame at given index is completely decoded.
-    WEBKIT_EXPORT bool isFrameCompleteAtIndex(int index) const;
+    BLINK_EXPORT bool isFrameCompleteAtIndex(int index) const;
 
     // Creates and returns WebImage from buffer at the index.
-    WEBKIT_EXPORT WebImage getFrameAtIndex(int index) const;
+    BLINK_EXPORT WebImage getFrameAtIndex(int index) const;
 
 private:
     // Creates type-specific decoder.
-    WEBKIT_EXPORT void init(Type type);
+    BLINK_EXPORT void init(Type type);
 
     WebImageDecoderPrivate* m_private;
 };
diff --git a/public/web/WebInputElement.h b/public/web/WebInputElement.h
index f351090..fdad920 100644
--- a/public/web/WebInputElement.h
+++ b/public/web/WebInputElement.h
@@ -33,7 +33,7 @@
 
 #include "WebFormControlElement.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class HTMLInputElement; }
 #endif
 
@@ -62,67 +62,67 @@
 
         // This returns true for all of textfield-looking types such as text,
         // password, search, email, url, and number.
-        WEBKIT_EXPORT bool isTextField() const;
+        BLINK_EXPORT bool isTextField() const;
         // This returns true only for type=text.
-        WEBKIT_EXPORT bool isText() const;
-        WEBKIT_EXPORT bool isPasswordField() const;
-        WEBKIT_EXPORT bool isImageButton() const;
-        WEBKIT_EXPORT bool isRadioButton() const;
-        WEBKIT_EXPORT bool isCheckbox() const;
-        WEBKIT_EXPORT bool autoComplete() const;
-        WEBKIT_EXPORT int maxLength() const;
-        WEBKIT_EXPORT bool isActivatedSubmit() const;
-        WEBKIT_EXPORT void setActivatedSubmit(bool);
-        WEBKIT_EXPORT int size() const;
-        WEBKIT_EXPORT void setValue(const WebString&, bool sendChangeEvent = false);
-        WEBKIT_EXPORT void setChecked(bool, bool sendChangeEvent = false);
-        WEBKIT_EXPORT WebString value() const;
+        BLINK_EXPORT bool isText() const;
+        BLINK_EXPORT bool isPasswordField() const;
+        BLINK_EXPORT bool isImageButton() const;
+        BLINK_EXPORT bool isRadioButton() const;
+        BLINK_EXPORT bool isCheckbox() const;
+        BLINK_EXPORT bool autoComplete() const;
+        BLINK_EXPORT int maxLength() const;
+        BLINK_EXPORT bool isActivatedSubmit() const;
+        BLINK_EXPORT void setActivatedSubmit(bool);
+        BLINK_EXPORT int size() const;
+        BLINK_EXPORT void setValue(const WebString&, bool sendChangeEvent = false);
+        BLINK_EXPORT void setChecked(bool, bool sendChangeEvent = false);
+        BLINK_EXPORT WebString value() const;
         // This returns the non-sanitized, exact value inside the text field.
-        WEBKIT_EXPORT WebString editingValue() const;
+        BLINK_EXPORT WebString editingValue() const;
         // Sets the value inside the text field without being sanitized.
         // Can't be used if a renderer doesn't exist or on a non text field type.
         // Caret will be moved to the end.
-        WEBKIT_EXPORT void setEditingValue(const WebString&);
-        WEBKIT_EXPORT void setSuggestedValue(const WebString&);
-        WEBKIT_EXPORT WebString suggestedValue() const;
-        WEBKIT_EXPORT void setPlaceholder(const WebString&);
-        WEBKIT_EXPORT WebString placeholder() const;
-        WEBKIT_EXPORT bool isAutofilled() const;
-        WEBKIT_EXPORT void setAutofilled(bool);
-        WEBKIT_EXPORT void setSelectionRange(int, int);
-        WEBKIT_EXPORT int selectionStart() const;
-        WEBKIT_EXPORT int selectionEnd() const;
-        WEBKIT_EXPORT bool isValidValue(const WebString&) const;
-        WEBKIT_EXPORT bool isChecked() const;
-        WEBKIT_EXPORT bool isMultiple() const;
+        BLINK_EXPORT void setEditingValue(const WebString&);
+        BLINK_EXPORT void setSuggestedValue(const WebString&);
+        BLINK_EXPORT WebString suggestedValue() const;
+        BLINK_EXPORT void setPlaceholder(const WebString&);
+        BLINK_EXPORT WebString placeholder() const;
+        BLINK_EXPORT bool isAutofilled() const;
+        BLINK_EXPORT void setAutofilled(bool);
+        BLINK_EXPORT void setSelectionRange(int, int);
+        BLINK_EXPORT int selectionStart() const;
+        BLINK_EXPORT int selectionEnd() const;
+        BLINK_EXPORT bool isValidValue(const WebString&) const;
+        BLINK_EXPORT bool isChecked() const;
+        BLINK_EXPORT bool isMultiple() const;
 
-        WEBKIT_EXPORT WebNodeCollection dataListOptions() const;
+        BLINK_EXPORT WebNodeCollection dataListOptions() const;
 
         // Return the localized value for this input type.
-        WEBKIT_EXPORT WebString localizeValue(const WebString&) const;
+        BLINK_EXPORT WebString localizeValue(const WebString&) const;
 
-        WEBKIT_EXPORT bool isSpeechInputEnabled() const;
-        WEBKIT_EXPORT SpeechInputState getSpeechInputState() const;
-        WEBKIT_EXPORT void startSpeechInput();
-        WEBKIT_EXPORT void stopSpeechInput();
+        BLINK_EXPORT bool isSpeechInputEnabled() const;
+        BLINK_EXPORT SpeechInputState getSpeechInputState() const;
+        BLINK_EXPORT void startSpeechInput();
+        BLINK_EXPORT void stopSpeechInput();
 
         // Exposes the default value of the maxLength attribute.
-        WEBKIT_EXPORT static int defaultMaxLength();
+        BLINK_EXPORT static int defaultMaxLength();
 
         // Returns the direction of the text in this element.
-        WEBKIT_EXPORT WebString directionForFormData() const;
+        BLINK_EXPORT WebString directionForFormData() const;
 
-        WEBKIT_EXPORT WebElement decorationElementFor(void*);
-        WEBKIT_EXPORT WebElement passwordGeneratorButtonElement() const;
+        BLINK_EXPORT WebElement decorationElementFor(void*);
+        BLINK_EXPORT WebElement passwordGeneratorButtonElement() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
         WebInputElement(const WTF::PassRefPtr<WebCore::HTMLInputElement>&);
         WebInputElement& operator=(const WTF::PassRefPtr<WebCore::HTMLInputElement>&);
         operator WTF::PassRefPtr<WebCore::HTMLInputElement>() const;
 #endif
     };
 
-    WEBKIT_EXPORT WebInputElement* toWebInputElement(WebElement*);
+    BLINK_EXPORT WebInputElement* toWebInputElement(WebElement*);
 
     inline const WebInputElement* toWebInputElement(const WebElement* element)
     {
diff --git a/public/web/WebInputEvent.h b/public/web/WebInputEvent.h
index a0e4582..7aff6fd 100644
--- a/public/web/WebInputEvent.h
+++ b/public/web/WebInputEvent.h
@@ -302,7 +302,7 @@
 
     // Sets keyIdentifier based on the value of windowsKeyCode.  This is
     // handy for generating synthetic keyboard events.
-    WEBKIT_EXPORT void setKeyIdentifierFromWindowsKeyCode();
+    BLINK_EXPORT void setKeyIdentifierFromWindowsKeyCode();
 
     static int windowsKeyCodeWithoutLocation(int keycode);
     static int locationModifiersFromWindowsKeyCode(int keycode);
diff --git a/public/web/WebKit.h b/public/web/WebKit.h
index 8e54c1b..3967311 100644
--- a/public/web/WebKit.h
+++ b/public/web/WebKit.h
@@ -33,25 +33,33 @@
 
 #include "../platform/Platform.h"
 
+namespace v8 {
+class Isolate;
+}
+
 namespace WebKit {
 
 // Must be called on the thread that will be the main WebKit thread before
 // using any other WebKit APIs. The provided Platform; must be
 // non-null and must remain valid until the current thread calls shutdown.
-WEBKIT_EXPORT void initialize(Platform*);
+BLINK_EXPORT void initialize(Platform*);
 
 // Must be called on the thread that will be the main WebKit thread before
 // using any other WebKit APIs. The provided Platform must be
 // non-null and must remain valid until the current thread calls shutdown.
 //
 // This is a special variant of initialize that does not intitialize V8.
-WEBKIT_EXPORT void initializeWithoutV8(Platform*);
+BLINK_EXPORT void initializeWithoutV8(Platform*);
+
+// Get the V8 Isolate for the main thread.
+// initialize must have been called first.
+BLINK_EXPORT v8::Isolate* mainThreadIsolate();
 
 // Once shutdown, the Platform passed to initialize will no longer
 // be accessed. No other WebKit objects should be in use when this function is
 // called. Any background threads created by WebKit are promised to be
 // terminated by the time this function returns.
-WEBKIT_EXPORT void shutdown();
+BLINK_EXPORT void shutdown();
 
 // Once shutdown, the Platform passed to initializeWithoutV8 will no longer
 // be accessed. No other WebKit objects should be in use when this function is
@@ -60,18 +68,18 @@
 //
 // If initializeWithoutV8() was used to initialize WebKit, shutdownWithoutV8
 // must be called to shut it down again.
-WEBKIT_EXPORT void shutdownWithoutV8();
+BLINK_EXPORT void shutdownWithoutV8();
 
 // Alters the rendering of content to conform to a fixed set of rules.
-WEBKIT_EXPORT void setLayoutTestMode(bool);
-WEBKIT_EXPORT bool layoutTestMode();
+BLINK_EXPORT void setLayoutTestMode(bool);
+BLINK_EXPORT bool layoutTestMode();
 
 // Enables the named log channel. See WebCore/platform/Logging.h for details.
-WEBKIT_EXPORT void enableLogChannel(const char*);
+BLINK_EXPORT void enableLogChannel(const char*);
 
 // Purge the plugin list cache. If |reloadPages| is true, any pages
 // containing plugins will be reloaded after refreshing the plugin list.
-WEBKIT_EXPORT void resetPluginCache(bool reloadPages);
+BLINK_EXPORT void resetPluginCache(bool reloadPages);
 
 } // namespace WebKit
 
diff --git a/public/web/WebLabelElement.h b/public/web/WebLabelElement.h
index 4a20bac..026af06 100644
--- a/public/web/WebLabelElement.h
+++ b/public/web/WebLabelElement.h
@@ -33,7 +33,7 @@
 
 #include "WebElement.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class HTMLLabelElement; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -54,9 +54,9 @@
 
     void assign(const WebLabelElement& element) { WebElement::assign(element); }
 
-    WEBKIT_EXPORT WebElement correspondingControl();
+    BLINK_EXPORT WebElement correspondingControl();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebLabelElement(const WTF::PassRefPtr<WebCore::HTMLLabelElement>&);
     WebLabelElement& operator=(const WTF::PassRefPtr<WebCore::HTMLLabelElement>&);
     operator WTF::PassRefPtr<WebCore::HTMLLabelElement>() const;
diff --git a/public/web/WebMIDIClientMock.h b/public/web/WebMIDIClientMock.h
index 65e4728..1728b2a 100644
--- a/public/web/WebMIDIClientMock.h
+++ b/public/web/WebMIDIClientMock.h
@@ -44,11 +44,11 @@
 
 class WebMIDIClientMock : public WebMIDIClient {
 public:
-    WEBKIT_EXPORT static WebMIDIClientMock* create();
+    BLINK_EXPORT static WebMIDIClientMock* create();
     virtual ~WebMIDIClientMock() { reset(); }
 
-    WEBKIT_EXPORT void setSysExPermission(bool);
-    WEBKIT_EXPORT void resetMock();
+    BLINK_EXPORT void setSysExPermission(bool);
+    BLINK_EXPORT void resetMock();
 
     // WebMIDIClient
     virtual void requestSysExPermission(const WebMIDIPermissionRequest&) OVERRIDE;
@@ -56,7 +56,7 @@
 
 private:
     WebMIDIClientMock();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
 
     WebPrivateOwnPtr<WebCore::MIDIClientMock> m_clientMock;
 };
diff --git a/public/web/WebMIDIPermissionRequest.h b/public/web/WebMIDIPermissionRequest.h
index 5a3408c..d5f051d 100644
--- a/public/web/WebMIDIPermissionRequest.h
+++ b/public/web/WebMIDIPermissionRequest.h
@@ -52,14 +52,14 @@
     WebMIDIPermissionRequest(const WebMIDIPermissionRequest& o) { assign(o); }
     ~WebMIDIPermissionRequest() { reset(); };
 
-    WEBKIT_EXPORT WebSecurityOrigin securityOrigin() const;
-    WEBKIT_EXPORT void setIsAllowed(bool);
+    BLINK_EXPORT WebSecurityOrigin securityOrigin() const;
+    BLINK_EXPORT void setIsAllowed(bool);
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebMIDIPermissionRequest&);
-    WEBKIT_EXPORT bool equals(const WebMIDIPermissionRequest&) const;
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebMIDIPermissionRequest&);
+    BLINK_EXPORT bool equals(const WebMIDIPermissionRequest&) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebMIDIPermissionRequest(const PassRefPtr<WebCore::MIDIAccess>&);
     explicit WebMIDIPermissionRequest(WebCore::MIDIAccess*);
 
diff --git a/public/web/WebMediaStreamRegistry.h b/public/web/WebMediaStreamRegistry.h
index 0843b39..3d16a36 100644
--- a/public/web/WebMediaStreamRegistry.h
+++ b/public/web/WebMediaStreamRegistry.h
@@ -40,7 +40,7 @@
 
 class WebMediaStreamRegistry {
 public:
-    WEBKIT_EXPORT static WebMediaStream lookupMediaStreamDescriptor(const WebURL&);
+    BLINK_EXPORT static WebMediaStream lookupMediaStreamDescriptor(const WebURL&);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebNetworkStateNotifier.h b/public/web/WebNetworkStateNotifier.h
index 0069c30..98904cb 100644
--- a/public/web/WebNetworkStateNotifier.h
+++ b/public/web/WebNetworkStateNotifier.h
@@ -37,7 +37,7 @@
 
 class WebNetworkStateNotifier {
 public:
-    WEBKIT_EXPORT static void setOnLine(bool);
+    BLINK_EXPORT static void setOnLine(bool);
 
 private:
     WebNetworkStateNotifier();
diff --git a/public/web/WebNode.h b/public/web/WebNode.h
index ebfb32b..8ccd0ef 100644
--- a/public/web/WebNode.h
+++ b/public/web/WebNode.h
@@ -65,13 +65,13 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebNode&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebNode&);
 
-    WEBKIT_EXPORT bool equals(const WebNode&) const;
+    BLINK_EXPORT bool equals(const WebNode&) const;
     // Required for using WebNodes in std maps.  Note the order used is
     // arbitrary and should not be expected to have any specific meaning.
-    WEBKIT_EXPORT bool lessThan(const WebNode&) const;
+    BLINK_EXPORT bool lessThan(const WebNode&) const;
 
     bool isNull() const { return m_private.isNull(); }
 
@@ -92,40 +92,40 @@
         ShadowRootNode = 14
     };
 
-    WEBKIT_EXPORT NodeType nodeType() const;
-    WEBKIT_EXPORT WebNode parentNode() const;
-    WEBKIT_EXPORT WebString nodeName() const;
-    WEBKIT_EXPORT WebString nodeValue() const;
-    WEBKIT_EXPORT bool setNodeValue(const WebString&);
-    WEBKIT_EXPORT WebDocument document() const;
-    WEBKIT_EXPORT WebNode firstChild() const;
-    WEBKIT_EXPORT WebNode lastChild() const;
-    WEBKIT_EXPORT WebNode previousSibling() const;
-    WEBKIT_EXPORT WebNode nextSibling() const;
-    WEBKIT_EXPORT bool hasChildNodes() const;
-    WEBKIT_EXPORT WebNodeList childNodes();
-    WEBKIT_EXPORT WebString createMarkup() const;
-    WEBKIT_EXPORT bool isLink() const;
-    WEBKIT_EXPORT bool isTextNode() const;
-    WEBKIT_EXPORT bool isFocusable() const;
-    WEBKIT_EXPORT bool isContentEditable() const;
-    WEBKIT_EXPORT bool isElementNode() const;
+    BLINK_EXPORT NodeType nodeType() const;
+    BLINK_EXPORT WebNode parentNode() const;
+    BLINK_EXPORT WebString nodeName() const;
+    BLINK_EXPORT WebString nodeValue() const;
+    BLINK_EXPORT bool setNodeValue(const WebString&);
+    BLINK_EXPORT WebDocument document() const;
+    BLINK_EXPORT WebNode firstChild() const;
+    BLINK_EXPORT WebNode lastChild() const;
+    BLINK_EXPORT WebNode previousSibling() const;
+    BLINK_EXPORT WebNode nextSibling() const;
+    BLINK_EXPORT bool hasChildNodes() const;
+    BLINK_EXPORT WebNodeList childNodes();
+    BLINK_EXPORT WebString createMarkup() const;
+    BLINK_EXPORT bool isLink() const;
+    BLINK_EXPORT bool isTextNode() const;
+    BLINK_EXPORT bool isFocusable() const;
+    BLINK_EXPORT bool isContentEditable() const;
+    BLINK_EXPORT bool isElementNode() const;
     // addEventListener only works with a small set of eventTypes.
-    WEBKIT_EXPORT void addEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture);
-    WEBKIT_EXPORT bool dispatchEvent(const WebDOMEvent&);
-    WEBKIT_EXPORT void simulateClick();
-    WEBKIT_EXPORT WebNodeList getElementsByTagName(const WebString&) const;
-    WEBKIT_EXPORT WebElement querySelector(const WebString&, WebExceptionCode&) const;
-    WEBKIT_EXPORT WebElement rootEditableElement() const;
-    WEBKIT_EXPORT bool focused() const;
-    WEBKIT_EXPORT bool remove();
+    BLINK_EXPORT void addEventListener(const WebString& eventType, WebDOMEventListener* listener, bool useCapture);
+    BLINK_EXPORT bool dispatchEvent(const WebDOMEvent&);
+    BLINK_EXPORT void simulateClick();
+    BLINK_EXPORT WebNodeList getElementsByTagName(const WebString&) const;
+    BLINK_EXPORT WebElement querySelector(const WebString&, WebExceptionCode&) const;
+    BLINK_EXPORT WebElement rootEditableElement() const;
+    BLINK_EXPORT bool focused() const;
+    BLINK_EXPORT bool remove();
 
     // Returns true if the node has a non-empty bounding box in layout.
     // This does not 100% guarantee the user can see it, but is pretty close.
     // Note: This method only works properly after layout has occurred.
-    WEBKIT_EXPORT bool hasNonEmptyBoundingBox() const;
-    WEBKIT_EXPORT WebPluginContainer* pluginContainer() const;
-    WEBKIT_EXPORT WebElement shadowHost() const;
+    BLINK_EXPORT bool hasNonEmptyBoundingBox() const;
+    BLINK_EXPORT WebPluginContainer* pluginContainer() const;
+    BLINK_EXPORT WebElement shadowHost() const;
 
     template<typename T> T to()
     {
@@ -141,13 +141,13 @@
         return res;
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebNode(const WTF::PassRefPtr<WebCore::Node>&);
     WebNode& operator=(const WTF::PassRefPtr<WebCore::Node>&);
     operator WTF::PassRefPtr<WebCore::Node>() const;
 #endif
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     template<typename T> T* unwrap()
     {
         return static_cast<T*>(m_private.get());
diff --git a/public/web/WebNodeCollection.h b/public/web/WebNodeCollection.h
index 004cc08..3d78b15 100644
--- a/public/web/WebNodeCollection.h
+++ b/public/web/WebNodeCollection.h
@@ -34,7 +34,7 @@
 #include "../platform/WebCommon.h"
 
 namespace WebCore { class HTMLCollection; }
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
 
@@ -56,14 +56,14 @@
 
     bool isNull() const { return !m_private; }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebNodeCollection&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebNodeCollection&);
 
-    WEBKIT_EXPORT unsigned length() const;
-    WEBKIT_EXPORT WebNode nextItem() const;
-    WEBKIT_EXPORT WebNode firstItem() const;
+    BLINK_EXPORT unsigned length() const;
+    BLINK_EXPORT WebNode nextItem() const;
+    BLINK_EXPORT WebNode firstItem() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebNodeCollection(const WTF::PassRefPtr<WebCore::HTMLCollection>&);
 #endif
 
diff --git a/public/web/WebNodeList.h b/public/web/WebNodeList.h
index c0137d9..060a640 100644
--- a/public/web/WebNodeList.h
+++ b/public/web/WebNodeList.h
@@ -34,7 +34,7 @@
 #include "../platform/WebCommon.h"
 
 namespace WebCore { class NodeList; }
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
 
@@ -54,13 +54,13 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebNodeList&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebNodeList&);
 
-    WEBKIT_EXPORT unsigned length() const;
-    WEBKIT_EXPORT WebNode item(size_t) const;
+    BLINK_EXPORT unsigned length() const;
+    BLINK_EXPORT WebNode item(size_t) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebNodeList(const WTF::PassRefPtr<WebCore::NodeList>&);
 #endif
 
diff --git a/public/web/WebNotification.h b/public/web/WebNotification.h
index 9974fba..be6196e 100644
--- a/public/web/WebNotification.h
+++ b/public/web/WebNotification.h
@@ -34,7 +34,7 @@
 #include "../platform/WebCommon.h"
 #include "WebTextDirection.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Notification; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -57,8 +57,8 @@
 
     ~WebNotification() { reset(); }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebNotification&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebNotification&);
 
     WebNotification& operator=(const WebNotification& other)
     {
@@ -68,39 +68,39 @@
 
     // Operators required to put WebNotification in an ordered map.
     bool equals(const WebNotification& other) const { return m_private == other.m_private; }
-    WEBKIT_EXPORT bool lessThan(const WebNotification& other) const;
+    BLINK_EXPORT bool lessThan(const WebNotification& other) const;
 
     // DEPRECATED: Always returns false.
-    WEBKIT_EXPORT bool isHTML() const;
+    BLINK_EXPORT bool isHTML() const;
 
     // DEPRECATED: Always returns an invalid URL.
-    WEBKIT_EXPORT WebURL url() const;
+    BLINK_EXPORT WebURL url() const;
 
-    WEBKIT_EXPORT WebURL iconURL() const;
-    WEBKIT_EXPORT WebString title() const;
-    WEBKIT_EXPORT WebString body() const;
-    WEBKIT_EXPORT WebTextDirection direction() const;
+    BLINK_EXPORT WebURL iconURL() const;
+    BLINK_EXPORT WebString title() const;
+    BLINK_EXPORT WebString body() const;
+    BLINK_EXPORT WebTextDirection direction() const;
 
-    WEBKIT_EXPORT WebString replaceId() const;
+    BLINK_EXPORT WebString replaceId() const;
 
     // Called if the presenter goes out of scope before the notification does.
-    WEBKIT_EXPORT void detachPresenter();
+    BLINK_EXPORT void detachPresenter();
 
     // Called to indicate the notification has been displayed.
-    WEBKIT_EXPORT void dispatchDisplayEvent();
+    BLINK_EXPORT void dispatchDisplayEvent();
 
     // Called to indicate an error has occurred with this notification.
-    WEBKIT_EXPORT void dispatchErrorEvent(const WebString& errorMessage);
+    BLINK_EXPORT void dispatchErrorEvent(const WebString& errorMessage);
 
     // Called to indicate the notification has been closed.  If it was
     // closed by the user (as opposed to automatically by the system),
     // the byUser parameter will be true.
-    WEBKIT_EXPORT void dispatchCloseEvent(bool byUser);
+    BLINK_EXPORT void dispatchCloseEvent(bool byUser);
 
     // Called to indicate the notification was clicked on.
-    WEBKIT_EXPORT void dispatchClickEvent();
+    BLINK_EXPORT void dispatchClickEvent();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebNotification(const WTF::PassRefPtr<WebCore::Notification>&);
     WebNotification& operator=(const WTF::PassRefPtr<WebCore::Notification>&);
     operator WTF::PassRefPtr<WebCore::Notification>() const;
diff --git a/public/web/WebOptionElement.h b/public/web/WebOptionElement.h
index 7c6f52a..f03a76b 100644
--- a/public/web/WebOptionElement.h
+++ b/public/web/WebOptionElement.h
@@ -34,7 +34,7 @@
 #include "../platform/WebVector.h"
 #include "WebElement.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class HTMLOptionElement; }
 #endif
 
@@ -53,17 +53,17 @@
     }
     void assign(const WebOptionElement& element) { WebElement::assign(element); }
 
-    WEBKIT_EXPORT void setValue(const WebString&);
-    WEBKIT_EXPORT WebString value() const;
+    BLINK_EXPORT void setValue(const WebString&);
+    BLINK_EXPORT WebString value() const;
 
-    WEBKIT_EXPORT int index() const;
-    WEBKIT_EXPORT WebString text() const;
-    WEBKIT_EXPORT bool defaultSelected() const;
-    WEBKIT_EXPORT void setDefaultSelected(bool);
-    WEBKIT_EXPORT WebString label() const;
-    WEBKIT_EXPORT bool isEnabled() const;
+    BLINK_EXPORT int index() const;
+    BLINK_EXPORT WebString text() const;
+    BLINK_EXPORT bool defaultSelected() const;
+    BLINK_EXPORT void setDefaultSelected(bool);
+    BLINK_EXPORT WebString label() const;
+    BLINK_EXPORT bool isEnabled() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebOptionElement(const WTF::PassRefPtr<WebCore::HTMLOptionElement>&);
     WebOptionElement& operator=(const WTF::PassRefPtr<WebCore::HTMLOptionElement>&);
     operator WTF::PassRefPtr<WebCore::HTMLOptionElement>() const;
diff --git a/public/web/WebPagePopup.h b/public/web/WebPagePopup.h
index 8d7d037..28db5bf 100644
--- a/public/web/WebPagePopup.h
+++ b/public/web/WebPagePopup.h
@@ -40,7 +40,7 @@
 
 class WebPagePopup : public WebWidget {
 public:
-    WEBKIT_EXPORT static WebPagePopup* create(WebWidgetClient*);
+    BLINK_EXPORT static WebPagePopup* create(WebWidgetClient*);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebPageSerializer.h b/public/web/WebPageSerializer.h
index 57298ae..e6129e7 100644
--- a/public/web/WebPageSerializer.h
+++ b/public/web/WebPageSerializer.h
@@ -56,14 +56,14 @@
     // resources (such as images and CSS) and adds them to the passed vector.
     // The first resource in that vector is the top frame contents.
     // Note that this also strips-out any script tag or link to JavaScript.
-    WEBKIT_EXPORT static void serialize(WebView*, WebVector<Resource>*);
+    BLINK_EXPORT static void serialize(WebView*, WebVector<Resource>*);
 
     // Serializes the WebView contents to a MHTML representation.
-    WEBKIT_EXPORT static WebCString serializeToMHTML(WebView*);
+    BLINK_EXPORT static WebCString serializeToMHTML(WebView*);
 
     // Similar to serializeToMHTML but uses binary encoding for the MHTML parts.
     // This results in a smaller MHTML file but it might not be supported by other browsers.
-    WEBKIT_EXPORT static WebCString serializeToMHTMLUsingBinaryEncoding(WebView*);
+    BLINK_EXPORT static WebCString serializeToMHTMLUsingBinaryEncoding(WebView*);
 
     // IMPORTANT:
     // The API below is an older implementation of a pageserialization that
@@ -88,7 +88,7 @@
     // saved links, which matched with vector:links one by one.
     // The parameter localDirectoryName is relative path of directory which
     // contain all saved auxiliary files included all sub frames and resources.
-    WEBKIT_EXPORT static bool serialize(WebFrame*,
+    BLINK_EXPORT static bool serialize(WebFrame*,
                                         bool recursive,
                                         WebPageSerializerClient*,
                                         const WebVector<WebURL>& links,
@@ -98,7 +98,7 @@
     // Retrieve all the resource for the passed view, including the main frame
     // and sub-frames. Returns true if all resources were retrieved
     // successfully.
-    WEBKIT_EXPORT static bool retrieveAllResources(WebView*,
+    BLINK_EXPORT static bool retrieveAllResources(WebView*,
                                                    const WebVector<WebCString>& supportedSchemes,
                                                    WebVector<WebURL>* resources,
                                                    WebVector<WebURL>* frames);
@@ -107,11 +107,11 @@
     // changing the unit tests instead.
 
     // Generate the META for charset declaration.
-    WEBKIT_EXPORT static WebString generateMetaCharsetDeclaration(const WebString& charset);
+    BLINK_EXPORT static WebString generateMetaCharsetDeclaration(const WebString& charset);
     // Generate the MOTW declaration.
-    WEBKIT_EXPORT static WebString generateMarkOfTheWebDeclaration(const WebURL&);
+    BLINK_EXPORT static WebString generateMarkOfTheWebDeclaration(const WebURL&);
     // Generate the default base tag declaration.
-    WEBKIT_EXPORT static WebString generateBaseTagDeclaration(const WebString& baseTarget);
+    BLINK_EXPORT static WebString generateBaseTagDeclaration(const WebString& baseTarget);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebPasswordFormData.h b/public/web/WebPasswordFormData.h
index 954bbc9..bd54f7e 100644
--- a/public/web/WebPasswordFormData.h
+++ b/public/web/WebPasswordFormData.h
@@ -41,7 +41,7 @@
 struct WebPasswordFormData {
     // If the provided form is suitable for password completion, isValid() will
     // return true;
-    WEBKIT_EXPORT WebPasswordFormData(const WebFormElement&);
+    BLINK_EXPORT WebPasswordFormData(const WebFormElement&);
 
     // If creation failed, return false.
     bool isValid() const { return action.isValid(); }
diff --git a/public/web/WebPerformance.h b/public/web/WebPerformance.h
index 5b5df2c..8309445 100644
--- a/public/web/WebPerformance.h
+++ b/public/web/WebPerformance.h
@@ -53,35 +53,35 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebPerformance&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebPerformance&);
 
     // This only returns one of {Other|Reload|BackForward}.
     // Form submits and link clicks all fall under other.
-    WEBKIT_EXPORT WebNavigationType navigationType() const;
+    BLINK_EXPORT WebNavigationType navigationType() const;
 
-    WEBKIT_EXPORT double navigationStart() const;
-    WEBKIT_EXPORT double unloadEventEnd() const;
-    WEBKIT_EXPORT double redirectStart() const;
-    WEBKIT_EXPORT double redirectEnd() const;
-    WEBKIT_EXPORT unsigned short redirectCount() const;
-    WEBKIT_EXPORT double fetchStart() const;
-    WEBKIT_EXPORT double domainLookupStart() const;
-    WEBKIT_EXPORT double domainLookupEnd() const;
-    WEBKIT_EXPORT double connectStart() const;
-    WEBKIT_EXPORT double connectEnd() const;
-    WEBKIT_EXPORT double requestStart() const;
-    WEBKIT_EXPORT double responseStart() const;
-    WEBKIT_EXPORT double responseEnd() const;
-    WEBKIT_EXPORT double domLoading() const;
-    WEBKIT_EXPORT double domInteractive() const;
-    WEBKIT_EXPORT double domContentLoadedEventStart() const;
-    WEBKIT_EXPORT double domContentLoadedEventEnd() const;
-    WEBKIT_EXPORT double domComplete() const;
-    WEBKIT_EXPORT double loadEventStart() const;
-    WEBKIT_EXPORT double loadEventEnd() const;
+    BLINK_EXPORT double navigationStart() const;
+    BLINK_EXPORT double unloadEventEnd() const;
+    BLINK_EXPORT double redirectStart() const;
+    BLINK_EXPORT double redirectEnd() const;
+    BLINK_EXPORT unsigned short redirectCount() const;
+    BLINK_EXPORT double fetchStart() const;
+    BLINK_EXPORT double domainLookupStart() const;
+    BLINK_EXPORT double domainLookupEnd() const;
+    BLINK_EXPORT double connectStart() const;
+    BLINK_EXPORT double connectEnd() const;
+    BLINK_EXPORT double requestStart() const;
+    BLINK_EXPORT double responseStart() const;
+    BLINK_EXPORT double responseEnd() const;
+    BLINK_EXPORT double domLoading() const;
+    BLINK_EXPORT double domInteractive() const;
+    BLINK_EXPORT double domContentLoadedEventStart() const;
+    BLINK_EXPORT double domContentLoadedEventEnd() const;
+    BLINK_EXPORT double domComplete() const;
+    BLINK_EXPORT double loadEventStart() const;
+    BLINK_EXPORT double loadEventEnd() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebPerformance(const WTF::PassRefPtr<WebCore::Performance>&);
     WebPerformance& operator=(const WTF::PassRefPtr<WebCore::Performance>&);
     operator WTF::PassRefPtr<WebCore::Performance>() const;
diff --git a/public/web/WebPluginDocument.h b/public/web/WebPluginDocument.h
index d7aa0d2..90aa231 100644
--- a/public/web/WebPluginDocument.h
+++ b/public/web/WebPluginDocument.h
@@ -33,7 +33,7 @@
 
 #include "WebDocument.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class PluginDocument; }
 #endif
 
@@ -53,9 +53,9 @@
     }
     void assign(const WebPluginDocument& d) { WebNode::assign(d); }
 
-    WEBKIT_EXPORT WebPlugin* plugin();
+    BLINK_EXPORT WebPlugin* plugin();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebPluginDocument(const WTF::PassRefPtr<WebCore::PluginDocument>&);
     WebPluginDocument& operator=(const WTF::PassRefPtr<WebCore::PluginDocument>&);
     operator WTF::PassRefPtr<WebCore::PluginDocument>() const;
diff --git a/public/web/WebPluginScrollbar.h b/public/web/WebPluginScrollbar.h
index 7715b45..82c4e81 100644
--- a/public/web/WebPluginScrollbar.h
+++ b/public/web/WebPluginScrollbar.h
@@ -39,14 +39,14 @@
 public:
     // Creates a WebPluginScrollbar for use by a plugin. The plugin container and
     // client are guaranteed to outlive this object.
-    WEBKIT_EXPORT static WebPluginScrollbar* createForPlugin(WebScrollbar::Orientation,
+    BLINK_EXPORT static WebPluginScrollbar* createForPlugin(WebScrollbar::Orientation,
                                                              WebPluginContainer*,
                                                              WebPluginScrollbarClient*);
 
     virtual ~WebPluginScrollbar() { }
 
     // Gets the thickness of the scrollbar in pixels.
-    WEBKIT_EXPORT static int defaultThickness();
+    BLINK_EXPORT static int defaultThickness();
 
     // Sets the rectangle of the scrollbar.
     virtual void setLocation(const WebRect&) = 0;
diff --git a/public/web/WebPopupMenu.h b/public/web/WebPopupMenu.h
index 2acd53e..f97b1fa 100644
--- a/public/web/WebPopupMenu.h
+++ b/public/web/WebPopupMenu.h
@@ -40,10 +40,10 @@
 
 class WebPopupMenu : public WebWidget {
 public:
-    WEBKIT_EXPORT static WebPopupMenu* create(WebWidgetClient*);
+    BLINK_EXPORT static WebPopupMenu* create(WebWidgetClient*);
 
     // Sets the minimum height of a popup listbox row.
-    WEBKIT_EXPORT static void setMinimumRowHeight(int);
+    BLINK_EXPORT static void setMinimumRowHeight(int);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebRange.h b/public/web/WebRange.h
index 18cfc54..f1eca40 100644
--- a/public/web/WebRange.h
+++ b/public/web/WebRange.h
@@ -34,7 +34,7 @@
 #include "../platform/WebCommon.h"
 #include "../platform/WebVector.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class Range; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -60,26 +60,26 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebRange&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebRange&);
 
     bool isNull() const { return !m_private; }
 
-    WEBKIT_EXPORT int startOffset() const;
-    WEBKIT_EXPORT int endOffset() const;
-    WEBKIT_EXPORT WebNode startContainer(int& exceptionCode) const;
-    WEBKIT_EXPORT WebNode endContainer(int& exceptionCode) const;
+    BLINK_EXPORT int startOffset() const;
+    BLINK_EXPORT int endOffset() const;
+    BLINK_EXPORT WebNode startContainer(int& exceptionCode) const;
+    BLINK_EXPORT WebNode endContainer(int& exceptionCode) const;
 
-    WEBKIT_EXPORT WebString toHTMLText() const;
-    WEBKIT_EXPORT WebString toPlainText() const;
+    BLINK_EXPORT WebString toHTMLText() const;
+    BLINK_EXPORT WebString toPlainText() const;
 
-    WEBKIT_EXPORT WebRange expandedToParagraph() const;
+    BLINK_EXPORT WebRange expandedToParagraph() const;
 
-    WEBKIT_EXPORT static WebRange fromDocumentRange(WebFrame*, int start, int length);
+    BLINK_EXPORT static WebRange fromDocumentRange(WebFrame*, int start, int length);
 
-    WEBKIT_EXPORT WebVector<WebFloatQuad> textQuads() const;
+    BLINK_EXPORT WebVector<WebFloatQuad> textQuads() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebRange(const WTF::PassRefPtr<WebCore::Range>&);
     WebRange& operator=(const WTF::PassRefPtr<WebCore::Range>&);
     operator WTF::PassRefPtr<WebCore::Range>() const;
diff --git a/public/web/WebRuntimeFeatures.h b/public/web/WebRuntimeFeatures.h
index 73d8e17..1ec413c 100644
--- a/public/web/WebRuntimeFeatures.h
+++ b/public/web/WebRuntimeFeatures.h
@@ -41,110 +41,115 @@
 // features Blink has made API commitments to.
 class WebRuntimeFeatures {
 public:
-    WEBKIT_EXPORT static void enableStableFeatures(bool);
-    WEBKIT_EXPORT static void enableExperimentalFeatures(bool);
-    WEBKIT_EXPORT static void enableTestOnlyFeatures(bool);
+    BLINK_EXPORT static void enableStableFeatures(bool);
+    BLINK_EXPORT static void enableExperimentalFeatures(bool);
+    BLINK_EXPORT static void enableTestOnlyFeatures(bool);
 
-    WEBKIT_EXPORT static void enableApplicationCache(bool);
-    WEBKIT_EXPORT static bool isApplicationCacheEnabled();
+    BLINK_EXPORT static void enableApplicationCache(bool);
+    BLINK_EXPORT static bool isApplicationCacheEnabled();
 
-    WEBKIT_EXPORT static void enableDatabase(bool);
-    WEBKIT_EXPORT static bool isDatabaseEnabled();
+    BLINK_EXPORT static void enableDatabase(bool);
+    BLINK_EXPORT static bool isDatabaseEnabled();
 
-    WEBKIT_EXPORT static void enableDeviceMotion(bool);
-    WEBKIT_EXPORT static bool isDeviceMotionEnabled();
+    BLINK_EXPORT static void enableDeviceMotion(bool);
+    BLINK_EXPORT static bool isDeviceMotionEnabled();
 
-    WEBKIT_EXPORT static void enableDeviceOrientation(bool);
-    WEBKIT_EXPORT static bool isDeviceOrientationEnabled();
+    BLINK_EXPORT static void enableDeviceOrientation(bool);
+    BLINK_EXPORT static bool isDeviceOrientationEnabled();
 
-    WEBKIT_EXPORT static void enableDialogElement(bool);
-    WEBKIT_EXPORT static bool isDialogElementEnabled();
+    BLINK_EXPORT static void enableDialogElement(bool);
+    BLINK_EXPORT static bool isDialogElementEnabled();
 
-    WEBKIT_EXPORT static void enableEncryptedMedia(bool);
-    WEBKIT_EXPORT static bool isEncryptedMediaEnabled();
+    BLINK_EXPORT static void enableEncryptedMedia(bool);
+    BLINK_EXPORT static bool isEncryptedMediaEnabled();
 
-    WEBKIT_EXPORT static void enableLegacyEncryptedMedia(bool);
-    WEBKIT_EXPORT static bool isLegacyEncryptedMediaEnabled();
+    BLINK_EXPORT static void enableLegacyEncryptedMedia(bool);
+    BLINK_EXPORT static bool isLegacyEncryptedMediaEnabled();
 
-    WEBKIT_EXPORT static void enableExperimentalCanvasFeatures(bool);
-    WEBKIT_EXPORT static bool isExperimentalCanvasFeaturesEnabled();
+    BLINK_EXPORT static void enablePrefixedEncryptedMedia(bool);
+    BLINK_EXPORT static bool isPrefixedEncryptedMediaEnabled();
 
-    WEBKIT_EXPORT static void enableFileSystem(bool);
-    WEBKIT_EXPORT static bool isFileSystemEnabled();
+    BLINK_EXPORT static void enableExperimentalCanvasFeatures(bool);
+    BLINK_EXPORT static bool isExperimentalCanvasFeaturesEnabled();
 
-    WEBKIT_EXPORT static void enableFullscreen(bool);
-    WEBKIT_EXPORT static bool isFullscreenEnabled();
+    BLINK_EXPORT static void enableFileSystem(bool);
+    BLINK_EXPORT static bool isFileSystemEnabled();
 
-    WEBKIT_EXPORT static void enableGamepad(bool);
-    WEBKIT_EXPORT static bool isGamepadEnabled();
+    BLINK_EXPORT static void enableFullscreen(bool);
+    BLINK_EXPORT static bool isFullscreenEnabled();
 
-    WEBKIT_EXPORT static void enableGeolocation(bool);
-    WEBKIT_EXPORT static bool isGeolocationEnabled();
+    BLINK_EXPORT static void enableGamepad(bool);
+    BLINK_EXPORT static bool isGamepadEnabled();
 
-    WEBKIT_EXPORT static void enableLazyLayout(bool);
+    BLINK_EXPORT static void enableGeolocation(bool);
+    BLINK_EXPORT static bool isGeolocationEnabled();
 
-    WEBKIT_EXPORT static void enableLocalStorage(bool);
-    WEBKIT_EXPORT static bool isLocalStorageEnabled();
+    BLINK_EXPORT static void enableLazyLayout(bool);
 
-    WEBKIT_EXPORT static void enableMediaPlayer(bool);
-    WEBKIT_EXPORT static bool isMediaPlayerEnabled();
+    BLINK_EXPORT static void enableLocalStorage(bool);
+    BLINK_EXPORT static bool isLocalStorageEnabled();
 
-    WEBKIT_EXPORT static void enableWebKitMediaSource(bool);
-    WEBKIT_EXPORT static bool isWebKitMediaSourceEnabled();
+    BLINK_EXPORT static void enableMediaPlayer(bool);
+    BLINK_EXPORT static bool isMediaPlayerEnabled();
 
-    WEBKIT_EXPORT static void enableMediaStream(bool);
-    WEBKIT_EXPORT static bool isMediaStreamEnabled();
+    BLINK_EXPORT static void enableWebKitMediaSource(bool);
+    BLINK_EXPORT static bool isWebKitMediaSourceEnabled();
 
-    WEBKIT_EXPORT static void enableNotifications(bool);
-    WEBKIT_EXPORT static bool isNotificationsEnabled();
+    BLINK_EXPORT static void enableMediaStream(bool);
+    BLINK_EXPORT static bool isMediaStreamEnabled();
 
-    WEBKIT_EXPORT static void enablePagePopup(bool);
-    WEBKIT_EXPORT static bool isPagePopupEnabled();
+    BLINK_EXPORT static void enableNotifications(bool);
+    BLINK_EXPORT static bool isNotificationsEnabled();
 
-    WEBKIT_EXPORT static void enablePeerConnection(bool);
-    WEBKIT_EXPORT static bool isPeerConnectionEnabled();
+    BLINK_EXPORT static void enablePagePopup(bool);
+    BLINK_EXPORT static bool isPagePopupEnabled();
 
-    WEBKIT_EXPORT static void enableRequestAutocomplete(bool);
-    WEBKIT_EXPORT static bool isRequestAutocompleteEnabled();
+    BLINK_EXPORT static void enablePeerConnection(bool);
+    BLINK_EXPORT static bool isPeerConnectionEnabled();
 
-    WEBKIT_EXPORT static void enableScriptedSpeech(bool);
-    WEBKIT_EXPORT static bool isScriptedSpeechEnabled();
+    BLINK_EXPORT static void enableRequestAutocomplete(bool);
+    BLINK_EXPORT static bool isRequestAutocompleteEnabled();
 
-    WEBKIT_EXPORT static void enableSessionStorage(bool);
-    WEBKIT_EXPORT static bool isSessionStorageEnabled();
+    BLINK_EXPORT static void enableScriptedSpeech(bool);
+    BLINK_EXPORT static bool isScriptedSpeechEnabled();
 
-    WEBKIT_EXPORT static void enableSpeechInput(bool);
-    WEBKIT_EXPORT static bool isSpeechInputEnabled();
+    BLINK_EXPORT static void enableSessionStorage(bool);
+    BLINK_EXPORT static bool isSessionStorageEnabled();
 
-    WEBKIT_EXPORT static void enableSpeechSynthesis(bool);
-    WEBKIT_EXPORT static bool isSpeechSynthesisEnabled();
+    BLINK_EXPORT static void enableSpeechInput(bool);
+    BLINK_EXPORT static bool isSpeechInputEnabled();
 
-    WEBKIT_EXPORT static void enableTouch(bool);
-    WEBKIT_EXPORT static bool isTouchEnabled();
+    BLINK_EXPORT static void enableSpeechSynthesis(bool);
+    BLINK_EXPORT static bool isSpeechSynthesisEnabled();
 
-    WEBKIT_EXPORT static void enableWebAnimationsCSS();
-    WEBKIT_EXPORT static void enableWebAnimationsSVG();
+    BLINK_EXPORT static void enableTouch(bool);
+    BLINK_EXPORT static bool isTouchEnabled();
 
-    WEBKIT_EXPORT static void enableWebAudio(bool);
-    WEBKIT_EXPORT static bool isWebAudioEnabled();
+    BLINK_EXPORT static void enableWebAnimationsCSS();
+    BLINK_EXPORT static void enableWebAnimationsSVG();
 
-    WEBKIT_EXPORT static void enableWebGLDraftExtensions(bool);
-    WEBKIT_EXPORT static bool isWebGLDraftExtensionsEnabled();
+    BLINK_EXPORT static void enableWebAudio(bool);
+    BLINK_EXPORT static bool isWebAudioEnabled();
 
-    WEBKIT_EXPORT static void enableWebMIDI(bool);
-    WEBKIT_EXPORT static bool isWebMIDIEnabled();
+    BLINK_EXPORT static void enableWebGLDraftExtensions(bool);
+    BLINK_EXPORT static bool isWebGLDraftExtensionsEnabled();
 
-    WEBKIT_EXPORT static void enableDataListElement(bool);
-    WEBKIT_EXPORT static bool isDataListElementEnabled();
+    BLINK_EXPORT static void enableWebMIDI(bool);
+    BLINK_EXPORT static bool isWebMIDIEnabled();
 
-    WEBKIT_EXPORT static void enableHTMLImports(bool);
-    WEBKIT_EXPORT static bool isHTMLImportsEnabled();
+    BLINK_EXPORT static void enableDataListElement(bool);
+    BLINK_EXPORT static bool isDataListElementEnabled();
 
-    WEBKIT_EXPORT static void enableEmbedderCustomElements(bool);
+    BLINK_EXPORT static void enableHTMLImports(bool);
+    BLINK_EXPORT static bool isHTMLImportsEnabled();
 
-    WEBKIT_EXPORT static void enableOverlayScrollbars(bool);
+    BLINK_EXPORT static void enableEmbedderCustomElements(bool);
 
-    WEBKIT_EXPORT static void enableInputModeAttribute(bool);
+    BLINK_EXPORT static void enableOverlayScrollbars(bool);
+
+    BLINK_EXPORT static void enableInputModeAttribute(bool);
+
+    BLINK_EXPORT static void enableOverlayFullscreenVideo(bool);
 
 private:
     WebRuntimeFeatures();
diff --git a/public/web/WebScopedMicrotaskSuppression.h b/public/web/WebScopedMicrotaskSuppression.h
index 21562bd..50c76f7 100644
--- a/public/web/WebScopedMicrotaskSuppression.h
+++ b/public/web/WebScopedMicrotaskSuppression.h
@@ -60,8 +60,8 @@
     ~WebScopedMicrotaskSuppression() { reset(); }
 
 private:
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void reset();
 
 #ifndef NDEBUG
     class Impl;
diff --git a/public/web/WebScopedUserGesture.h b/public/web/WebScopedUserGesture.h
index 0401dbc..98197d6 100644
--- a/public/web/WebScopedUserGesture.h
+++ b/public/web/WebScopedUserGesture.h
@@ -61,9 +61,9 @@
     ~WebScopedUserGesture() { reset(); }
 
 private:
-    WEBKIT_EXPORT void initialize();
-    WEBKIT_EXPORT void initializeWithToken(const WebUserGestureToken&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void initialize();
+    BLINK_EXPORT void initializeWithToken(const WebUserGestureToken&);
+    BLINK_EXPORT void reset();
 
     WebPrivateOwnPtr<WebCore::UserGestureIndicator> m_indicator;
 };
diff --git a/public/web/WebScriptBindings.h b/public/web/WebScriptBindings.h
index a91fe48..12b9d43 100644
--- a/public/web/WebScriptBindings.h
+++ b/public/web/WebScriptBindings.h
@@ -48,10 +48,10 @@
 public:
     // Efficiently converts a WebString to a v8::String. The caller must have
     // a HandleScope to guard the result's lifetime.
-    WEBKIT_EXPORT static v8::Local<v8::String> toV8String(const WebString&, v8::Isolate*);
+    BLINK_EXPORT static v8::Local<v8::String> toV8String(const WebString&, v8::Isolate*);
 
     // You can use v8::Value::toString() to get a v8::String, but remember to wrap that in a v8::TryCatch.
-    WEBKIT_EXPORT static WebString toWebString(v8::Handle<v8::String>);
+    BLINK_EXPORT static WebString toWebString(v8::Handle<v8::String>);
 };
 
 } // namespace WebKit
diff --git a/public/web/WebScriptController.h b/public/web/WebScriptController.h
index b5a2ec3..bc68c28 100644
--- a/public/web/WebScriptController.h
+++ b/public/web/WebScriptController.h
@@ -44,16 +44,16 @@
     // Registers a v8 extension to be available on webpages. Will only affect
     // v8 contexts initialized after this call. Takes ownership of the
     // v8::Extension object passed.
-    WEBKIT_EXPORT static void registerExtension(v8::Extension*);
+    BLINK_EXPORT static void registerExtension(v8::Extension*);
 
     // Enables special settings which are only applicable if V8 is executed
     // in the single thread which must be the main thread.
     // FIXME: make a try to dynamically detect when this condition is broken
     // and automatically switch off single thread mode.
-    WEBKIT_EXPORT static void enableV8SingleThreadMode();
+    BLINK_EXPORT static void enableV8SingleThreadMode();
 
     // Process any pending JavaScript console messages.
-    WEBKIT_EXPORT static void flushConsoleMessages();
+    BLINK_EXPORT static void flushConsoleMessages();
 
 private:
     WebScriptController();
diff --git a/public/web/WebSearchableFormData.h b/public/web/WebSearchableFormData.h
index 041e494..af18e9d 100644
--- a/public/web/WebSearchableFormData.h
+++ b/public/web/WebSearchableFormData.h
@@ -44,7 +44,7 @@
 public:
     // If the provided form is suitable for automated searching, isValid()
     // will return false.
-    WEBKIT_EXPORT WebSearchableFormData(const WebFormElement&, const WebInputElement& selectedInputElement = WebInputElement());
+    BLINK_EXPORT WebSearchableFormData(const WebFormElement&, const WebInputElement& selectedInputElement = WebInputElement());
 
     bool isValid() { return m_url.isValid(); }
 
diff --git a/public/web/WebSecurityOrigin.h b/public/web/WebSecurityOrigin.h
index 41d0257..7b36270 100644
--- a/public/web/WebSecurityOrigin.h
+++ b/public/web/WebSecurityOrigin.h
@@ -33,7 +33,7 @@
 
 #include "../platform/WebCommon.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class SecurityOrigin; }
 namespace WTF { template <typename T> class PassRefPtr; }
 #endif
@@ -56,50 +56,50 @@
         return *this;
     }
 
-    WEBKIT_EXPORT static WebSecurityOrigin createFromDatabaseIdentifier(const WebString& databaseIdentifier);
-    WEBKIT_EXPORT static WebSecurityOrigin createFromString(const WebString&);
-    WEBKIT_EXPORT static WebSecurityOrigin create(const WebURL&);
+    BLINK_EXPORT static WebSecurityOrigin createFromDatabaseIdentifier(const WebString& databaseIdentifier);
+    BLINK_EXPORT static WebSecurityOrigin createFromString(const WebString&);
+    BLINK_EXPORT static WebSecurityOrigin create(const WebURL&);
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebSecurityOrigin&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebSecurityOrigin&);
 
     bool isNull() const { return !m_private; }
 
-    WEBKIT_EXPORT WebString protocol() const;
-    WEBKIT_EXPORT WebString host() const;
-    WEBKIT_EXPORT unsigned short port() const;
+    BLINK_EXPORT WebString protocol() const;
+    BLINK_EXPORT WebString host() const;
+    BLINK_EXPORT unsigned short port() const;
 
     // A unique WebSecurityOrigin is the least privileged WebSecurityOrigin.
-    WEBKIT_EXPORT bool isUnique() const;
+    BLINK_EXPORT bool isUnique() const;
 
     // Returns true if this WebSecurityOrigin can script objects in the given
     // SecurityOrigin. For example, call this function before allowing
     // script from one security origin to read or write objects from
     // another SecurityOrigin.
-    WEBKIT_EXPORT bool canAccess(const WebSecurityOrigin&) const;
+    BLINK_EXPORT bool canAccess(const WebSecurityOrigin&) const;
 
     // Returns true if this WebSecurityOrigin can read content retrieved from
     // the given URL. For example, call this function before allowing script
     // from a given security origin to receive contents from a given URL.
-    WEBKIT_EXPORT bool canRequest(const WebURL&) const;
+    BLINK_EXPORT bool canRequest(const WebURL&) const;
 
     // Returns a string representation of the WebSecurityOrigin.  The empty
     // WebSecurityOrigin is represented by "null".  The representation of a
     // non-empty WebSecurityOrigin resembles a standard URL.
-    WEBKIT_EXPORT WebString toString() const;
+    BLINK_EXPORT WebString toString() const;
 
     // Returns a string representation of this WebSecurityOrigin that can
     // be used as a file.  Should be used in storage APIs only.
-    WEBKIT_EXPORT WebString databaseIdentifier() const;
+    BLINK_EXPORT WebString databaseIdentifier() const;
 
     // Returns true if this WebSecurityOrigin can access usernames and
     // passwords stored in password manager.
-    WEBKIT_EXPORT bool canAccessPasswordManager() const;
+    BLINK_EXPORT bool canAccessPasswordManager() const;
 
     // Allows this WebSecurityOrigin access to local resources.
-    WEBKIT_EXPORT void grantLoadLocalResources() const;
+    BLINK_EXPORT void grantLoadLocalResources() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSecurityOrigin(const WTF::PassRefPtr<WebCore::SecurityOrigin>&);
     WebSecurityOrigin& operator=(const WTF::PassRefPtr<WebCore::SecurityOrigin>&);
     operator WTF::PassRefPtr<WebCore::SecurityOrigin>() const;
diff --git a/public/web/WebSecurityPolicy.h b/public/web/WebSecurityPolicy.h
index 0e63176..b5a5fcc 100644
--- a/public/web/WebSecurityPolicy.h
+++ b/public/web/WebSecurityPolicy.h
@@ -44,50 +44,50 @@
     // Registers a URL scheme to be treated as a local scheme (i.e., with the
     // same security rules as those applied to "file" URLs). This means that
     // normal pages cannot link to or access URLs of this scheme.
-    WEBKIT_EXPORT static void registerURLSchemeAsLocal(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsLocal(const WebString&);
 
     // Registers a URL scheme to be treated as a noAccess scheme. This means
     // that pages loaded with this URL scheme cannot access pages loaded with
     // any other URL scheme.
-    WEBKIT_EXPORT static void registerURLSchemeAsNoAccess(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsNoAccess(const WebString&);
 
     // Registers a URL scheme to be treated as display-isolated. This means
     // that pages cannot display these URLs unless they are from the same
     // scheme. For example, pages in other origin cannot create iframes or
     // hyperlinks to URLs with the scheme.
-    WEBKIT_EXPORT static void registerURLSchemeAsDisplayIsolated(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsDisplayIsolated(const WebString&);
 
     // Registers a URL scheme to not generate mixed content warnings when
     // included by an HTTPS page.
-    WEBKIT_EXPORT static void registerURLSchemeAsSecure(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsSecure(const WebString&);
 
     // Registers a non-HTTP URL scheme which can be sent CORS requests.
-    WEBKIT_EXPORT static void registerURLSchemeAsCORSEnabled(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsCORSEnabled(const WebString&);
 
     // Registers a URL scheme whose resources can be loaded regardless of a page's Content Security Policy.
-    WEBKIT_EXPORT static void registerURLSchemeAsBypassingContentSecurityPolicy(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsBypassingContentSecurityPolicy(const WebString&);
 
     // Registers a URL scheme as strictly empty documents, allowing them to
     // commit synchronously.
-    WEBKIT_EXPORT static void registerURLSchemeAsEmptyDocument(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsEmptyDocument(const WebString&);
 
     // Support for whitelisting access to origins beyond the same-origin policy.
-    WEBKIT_EXPORT static void addOriginAccessWhitelistEntry(
+    BLINK_EXPORT static void addOriginAccessWhitelistEntry(
         const WebURL& sourceOrigin, const WebString& destinationProtocol,
         const WebString& destinationHost, bool allowDestinationSubdomains);
-    WEBKIT_EXPORT static void removeOriginAccessWhitelistEntry(
+    BLINK_EXPORT static void removeOriginAccessWhitelistEntry(
         const WebURL& sourceOrigin, const WebString& destinationProtocol,
         const WebString& destinationHost, bool allowDestinationSubdomains);
-    WEBKIT_EXPORT static void resetOriginAccessWhitelists();
+    BLINK_EXPORT static void resetOriginAccessWhitelists();
 
     // Returns the referrer modified according to the referrer policy for a
     // navigation to a given URL. If the referrer returned is empty, the
     // referrer header should be omitted.
-    WEBKIT_EXPORT static WebString generateReferrerHeader(WebReferrerPolicy, const WebURL&, const WebString& referrer);
+    BLINK_EXPORT static WebString generateReferrerHeader(WebReferrerPolicy, const WebURL&, const WebString& referrer);
 
     // Registers an URL scheme to not allow manipulation of the loaded page
     // by bookmarklets or javascript: URLs typed in the omnibox.
-    WEBKIT_EXPORT static void registerURLSchemeAsNotAllowingJavascriptURLs(const WebString&);
+    BLINK_EXPORT static void registerURLSchemeAsNotAllowingJavascriptURLs(const WebString&);
 
 private:
     WebSecurityPolicy();
diff --git a/public/web/WebSelectElement.h b/public/web/WebSelectElement.h
index d3fc9b8..a00d480 100644
--- a/public/web/WebSelectElement.h
+++ b/public/web/WebSelectElement.h
@@ -35,7 +35,7 @@
 #include "WebFormControlElement.h"
 #include "WebOptionElement.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class HTMLSelectElement; }
 #endif
 
@@ -54,11 +54,11 @@
     }
     void assign(const WebSelectElement& element) { WebFormControlElement::assign(element); }
 
-    WEBKIT_EXPORT void setValue(const WebString&);
-    WEBKIT_EXPORT WebString value() const;
-    WEBKIT_EXPORT WebVector<WebElement> listItems() const;
+    BLINK_EXPORT void setValue(const WebString&);
+    BLINK_EXPORT WebString value() const;
+    BLINK_EXPORT WebVector<WebElement> listItems() const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSelectElement(const WTF::PassRefPtr<WebCore::HTMLSelectElement>&);
     WebSelectElement& operator=(const WTF::PassRefPtr<WebCore::HTMLSelectElement>&);
     operator WTF::PassRefPtr<WebCore::HTMLSelectElement>() const;
diff --git a/public/web/WebSelector.h b/public/web/WebSelector.h
index b49faaa..8a5514d 100644
--- a/public/web/WebSelector.h
+++ b/public/web/WebSelector.h
@@ -48,7 +48,7 @@
 // Returns the value that would be returned from CSSStyleRule.selectorText in the CSSOM for a rule with this selector (which can be a list), if the selector is valid and each component in the list has the type specified in |restriction|.
 // Returns "" for an invalid selector or a selector that doesn't match the restrictions.
 // The canonical form is not guaranteed to stay the same over time.
-WEBKIT_EXPORT WebString canonicalizeSelector(WebString selector, WebSelectorType restriction = WebSelectorTypeComplex);
+BLINK_EXPORT WebString canonicalizeSelector(WebString selector, WebSelectorType restriction = WebSelectorTypeComplex);
 
 } // namespace WebKit
 
diff --git a/public/web/WebSerializedScriptValue.h b/public/web/WebSerializedScriptValue.h
index 0958318..5dc3fe2 100644
--- a/public/web/WebSerializedScriptValue.h
+++ b/public/web/WebSerializedScriptValue.h
@@ -57,25 +57,25 @@
         return *this;
     }
 
-    WEBKIT_EXPORT static WebSerializedScriptValue fromString(const WebString&);
+    BLINK_EXPORT static WebSerializedScriptValue fromString(const WebString&);
 
-    WEBKIT_EXPORT static WebSerializedScriptValue serialize(v8::Handle<v8::Value>);
+    BLINK_EXPORT static WebSerializedScriptValue serialize(v8::Handle<v8::Value>);
 
     // Create a WebSerializedScriptValue that represents a serialization error.
-    WEBKIT_EXPORT static WebSerializedScriptValue createInvalid();
+    BLINK_EXPORT static WebSerializedScriptValue createInvalid();
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebSerializedScriptValue&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebSerializedScriptValue&);
 
     bool isNull() const { return m_private.isNull(); }
 
     // Returns a string representation of the WebSerializedScriptValue.
-    WEBKIT_EXPORT WebString toString() const;
+    BLINK_EXPORT WebString toString() const;
 
     // Convert the serialized value to a parsed v8 value.
-    WEBKIT_EXPORT v8::Handle<v8::Value> deserialize();
+    BLINK_EXPORT v8::Handle<v8::Value> deserialize();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSerializedScriptValue(const WTF::PassRefPtr<WebCore::SerializedScriptValue>&);
     WebSerializedScriptValue& operator=(const WTF::PassRefPtr<WebCore::SerializedScriptValue>&);
     operator WTF::PassRefPtr<WebCore::SerializedScriptValue>() const;
diff --git a/public/web/WebSettings.h b/public/web/WebSettings.h
index 9518a8a..cf2f86f 100644
--- a/public/web/WebSettings.h
+++ b/public/web/WebSettings.h
@@ -112,6 +112,7 @@
     virtual void setFullScreenEnabled(bool) = 0;
     virtual void setGestureTapHighlightEnabled(bool) = 0;
     virtual void setHyperlinkAuditingEnabled(bool) = 0;
+    virtual void setIgnoreMainFrameOverflowHiddenQuirk(bool) = 0;
     virtual void setImagesEnabled(bool) = 0;
     virtual void setJavaEnabled(bool) = 0;
     virtual void setJavaScriptCanAccessClipboard(bool) = 0;
diff --git a/public/web/WebSharedWorker.h b/public/web/WebSharedWorker.h
index 5340ca5..67fd984 100644
--- a/public/web/WebSharedWorker.h
+++ b/public/web/WebSharedWorker.h
@@ -50,7 +50,7 @@
 class WebSharedWorker {
 public:
     // Invoked from the worker thread to instantiate a WebSharedWorker that interacts with the WebKit worker components.
-    WEBKIT_EXPORT static WebSharedWorker* create(WebSharedWorkerClient*);
+    BLINK_EXPORT static WebSharedWorker* create(WebSharedWorkerClient*);
 
     virtual ~WebSharedWorker() {};
 
diff --git a/public/web/WebSharedWorkerRepository.h b/public/web/WebSharedWorkerRepository.h
index a5014f7..34c4a91 100644
--- a/public/web/WebSharedWorkerRepository.h
+++ b/public/web/WebSharedWorkerRepository.h
@@ -55,7 +55,7 @@
 };
 
 // Initializes shared worker support.
-WEBKIT_EXPORT void setSharedWorkerRepository(WebSharedWorkerRepository*);
+BLINK_EXPORT void setSharedWorkerRepository(WebSharedWorkerRepository*);
 
 } // namespace WebKit
 
diff --git a/public/web/WebSocket.h b/public/web/WebSocket.h
index 5cbad07..9a3735c 100644
--- a/public/web/WebSocket.h
+++ b/public/web/WebSocket.h
@@ -70,7 +70,7 @@
         BinaryTypeArrayBuffer = 1
     };
 
-    WEBKIT_EXPORT static WebSocket* create(const WebDocument&, WebSocketClient*);
+    BLINK_EXPORT static WebSocket* create(const WebDocument&, WebSocketClient*);
     virtual ~WebSocket() { }
 
     // These functions come from binaryType attribute of the WebSocket API
diff --git a/public/web/WebSpeechGrammar.h b/public/web/WebSpeechGrammar.h
index b1de20a..c5267f1 100644
--- a/public/web/WebSpeechGrammar.h
+++ b/public/web/WebSpeechGrammar.h
@@ -42,13 +42,13 @@
     WebSpeechGrammar(const WebSpeechGrammar& grammar) { assign(grammar); }
     ~WebSpeechGrammar() { reset(); }
 
-    WEBKIT_EXPORT WebURL src() const;
-    WEBKIT_EXPORT float weight() const;
+    BLINK_EXPORT WebURL src() const;
+    BLINK_EXPORT float weight() const;
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebSpeechGrammar&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebSpeechGrammar&);
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSpeechGrammar(const WTF::PassRefPtr<WebCore::SpeechGrammar>&);
     WebSpeechGrammar& operator=(const WTF::PassRefPtr<WebCore::SpeechGrammar>&);
 #endif
diff --git a/public/web/WebSpeechInputResult.h b/public/web/WebSpeechInputResult.h
index f9e6581..4f4ac95 100644
--- a/public/web/WebSpeechInputResult.h
+++ b/public/web/WebSpeechInputResult.h
@@ -51,11 +51,11 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void assign(const WebString& utterance, double confidence);
-    WEBKIT_EXPORT void assign(const WebSpeechInputResult& other);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebString& utterance, double confidence);
+    BLINK_EXPORT void assign(const WebSpeechInputResult& other);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSpeechInputResult(const WTF::PassRefPtr<WebCore::SpeechInputResult>&);
     operator WTF::PassRefPtr<WebCore::SpeechInputResult>() const;
 #endif
diff --git a/public/web/WebSpeechRecognitionHandle.h b/public/web/WebSpeechRecognitionHandle.h
index 4a2f6f6..af1d917 100644
--- a/public/web/WebSpeechRecognitionHandle.h
+++ b/public/web/WebSpeechRecognitionHandle.h
@@ -53,15 +53,15 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
-    WEBKIT_EXPORT void assign(const WebSpeechRecognitionHandle&);
+    BLINK_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebSpeechRecognitionHandle&);
 
     // Comparison functions are provided so that WebSpeechRecognitionHandle objects
     // can be stored in a hash map.
-    WEBKIT_EXPORT bool equals(const WebSpeechRecognitionHandle&) const;
-    WEBKIT_EXPORT bool lessThan(const WebSpeechRecognitionHandle&) const;
+    BLINK_EXPORT bool equals(const WebSpeechRecognitionHandle&) const;
+    BLINK_EXPORT bool lessThan(const WebSpeechRecognitionHandle&) const;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebSpeechRecognitionHandle(const WTF::PassRefPtr<WebCore::SpeechRecognition>&);
     WebSpeechRecognitionHandle& operator=(const WTF::PassRefPtr<WebCore::SpeechRecognition>&);
     operator WTF::PassRefPtr<WebCore::SpeechRecognition>() const;
diff --git a/public/web/WebSpeechRecognitionResult.h b/public/web/WebSpeechRecognitionResult.h
index 0c38105..1a224a0 100644
--- a/public/web/WebSpeechRecognitionResult.h
+++ b/public/web/WebSpeechRecognitionResult.h
@@ -43,11 +43,11 @@
     WebSpeechRecognitionResult(const WebSpeechRecognitionResult& result) { assign(result); }
     ~WebSpeechRecognitionResult() { reset(); }
 
-    WEBKIT_EXPORT void assign(const WebVector<WebString>& transcripts, const WebVector<float>& confidences, bool final);
-    WEBKIT_EXPORT void assign(const WebSpeechRecognitionResult&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebVector<WebString>& transcripts, const WebVector<float>& confidences, bool final);
+    BLINK_EXPORT void assign(const WebSpeechRecognitionResult&);
+    BLINK_EXPORT void reset();
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     operator WTF::PassRefPtr<WebCore::SpeechRecognitionResult>() const;
 #endif
 
diff --git a/public/web/WebStorageEventDispatcher.h b/public/web/WebStorageEventDispatcher.h
index e7b4399..32f260d 100644
--- a/public/web/WebStorageEventDispatcher.h
+++ b/public/web/WebStorageEventDispatcher.h
@@ -42,14 +42,14 @@
 class WebStorageEventDispatcher {
 public:
     // Dispatch a local storage event to appropiate documents.
-    WEBKIT_EXPORT static void dispatchLocalStorageEvent(
+    BLINK_EXPORT static void dispatchLocalStorageEvent(
             const WebString& key, const WebString& oldValue,
             const WebString& newValue, const WebURL& origin,
             const WebURL& pageUrl, WebStorageArea* sourceAreaInstance,
             bool originatedInProcess);
 
     // Dispatch a session storage event to appropiate documents.
-    WEBKIT_EXPORT static void dispatchSessionStorageEvent(
+    BLINK_EXPORT static void dispatchSessionStorageEvent(
             const WebString& key, const WebString& oldValue,
             const WebString& newValue, const WebURL& origin,
             const WebURL& pageUrl, const WebStorageNamespace&,
diff --git a/public/web/WebSurroundingText.h b/public/web/WebSurroundingText.h
index 39dfc8f..85949a8 100644
--- a/public/web/WebSurroundingText.h
+++ b/public/web/WebSurroundingText.h
@@ -45,21 +45,21 @@
     WebSurroundingText() { }
     ~WebSurroundingText() { reset(); }
 
-    WEBKIT_EXPORT bool isNull() const;
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT bool isNull() const;
+    BLINK_EXPORT void reset();
 
     // Initializes the object to get the surrounding text centered in the position relative to a provided node.
     // The maximum length of the contents retrieved is defined by maxLength.
-    WEBKIT_EXPORT void initialize(const WebNode&, const WebPoint&, size_t maxLength);
+    BLINK_EXPORT void initialize(const WebNode&, const WebPoint&, size_t maxLength);
 
     // Surrounding text content retrieved.
-    WEBKIT_EXPORT WebString textContent() const;
+    BLINK_EXPORT WebString textContent() const;
 
     // Offset in the text content of the initial hit position (or provided offset in the node).
-    WEBKIT_EXPORT size_t hitOffsetInTextContent() const;
+    BLINK_EXPORT size_t hitOffsetInTextContent() const;
 
     // Convert start/end positions in the content text string into a WebKit text range.
-    WEBKIT_EXPORT WebRange rangeFromContentOffsets(size_t startOffsetInContent, size_t endOffsetInContent);
+    BLINK_EXPORT WebRange rangeFromContentOffsets(size_t startOffsetInContent, size_t endOffsetInContent);
 
 protected:
     WebPrivateOwnPtr<WebCore::SurroundingText> m_private;
diff --git a/public/web/WebTestingSupport.h b/public/web/WebTestingSupport.h
index 1cb7c2c..8e5be8a 100644
--- a/public/web/WebTestingSupport.h
+++ b/public/web/WebTestingSupport.h
@@ -34,8 +34,8 @@
 
 class WebTestingSupport {
 public:
-    WEBKIT_EXPORT static void injectInternalsObject(WebFrame*);
-    WEBKIT_EXPORT static void resetInternalsObject(WebFrame*);
+    BLINK_EXPORT static void injectInternalsObject(WebFrame*);
+    BLINK_EXPORT static void resetInternalsObject(WebFrame*);
 };
 
 }
diff --git a/public/web/WebTextCheckingResult.h b/public/web/WebTextCheckingResult.h
index 3520445..8be9756 100644
--- a/public/web/WebTextCheckingResult.h
+++ b/public/web/WebTextCheckingResult.h
@@ -60,7 +60,7 @@
     {
     }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     operator WebCore::TextCheckingResult() const;
 #endif
 
diff --git a/public/web/WebTextInputInfo.h b/public/web/WebTextInputInfo.h
index c1b7fce..cf81f17 100644
--- a/public/web/WebTextInputInfo.h
+++ b/public/web/WebTextInputInfo.h
@@ -55,7 +55,7 @@
     // This string is lower-case.
     WebString inputMode;
 
-    WEBKIT_EXPORT bool equals(const WebTextInputInfo&) const;
+    BLINK_EXPORT bool equals(const WebTextInputInfo&) const;
 
     WebTextInputInfo()
         : type(WebTextInputTypeNone)
diff --git a/public/web/WebTextRun.h b/public/web/WebTextRun.h
index d19ea2e..15315cf 100644
--- a/public/web/WebTextRun.h
+++ b/public/web/WebTextRun.h
@@ -33,7 +33,7 @@
 
 #include "../platform/WebString.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 namespace WebCore { class TextRun; }
 #endif
 
@@ -56,7 +56,7 @@
     bool rtl;
     bool directionalOverride;
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     // The resulting WebCore::TextRun will refer to the text in this
     // struct, so "this" must outlive the WebCore text run.
     operator WebCore::TextRun() const;
diff --git a/public/web/WebUserGestureIndicator.h b/public/web/WebUserGestureIndicator.h
index d4ff05f..25364eb 100644
--- a/public/web/WebUserGestureIndicator.h
+++ b/public/web/WebUserGestureIndicator.h
@@ -40,15 +40,15 @@
 class WebUserGestureIndicator {
 public:
     // Returns true if a user gesture is currently being processed.
-    WEBKIT_EXPORT static bool isProcessingUserGesture();
+    BLINK_EXPORT static bool isProcessingUserGesture();
 
     // Returns true if a consumable gesture exists and has been successfully consumed.
-    WEBKIT_EXPORT static bool consumeUserGesture();
+    BLINK_EXPORT static bool consumeUserGesture();
 
     // Returns a token for the currently active user gesture. It can be used to
     // continue processing the user gesture later on using a
     // WebScopedUserGesture.
-    WEBKIT_EXPORT static WebUserGestureToken currentUserGestureToken();
+    BLINK_EXPORT static WebUserGestureToken currentUserGestureToken();
 };
 
 }
diff --git a/public/web/WebUserGestureToken.h b/public/web/WebUserGestureToken.h
index dbfddc9..7f0986d 100644
--- a/public/web/WebUserGestureToken.h
+++ b/public/web/WebUserGestureToken.h
@@ -53,19 +53,19 @@
     }
     ~WebUserGestureToken() { reset(); }
 
-    WEBKIT_EXPORT bool hasGestures() const;
-    WEBKIT_EXPORT void setOutOfProcess();
-    WEBKIT_EXPORT void setJavascriptPrompt();
+    BLINK_EXPORT bool hasGestures() const;
+    BLINK_EXPORT void setOutOfProcess();
+    BLINK_EXPORT void setJavascriptPrompt();
     bool isNull() const { return m_token.isNull(); }
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     explicit WebUserGestureToken(PassRefPtr<WebCore::UserGestureToken>);
     operator PassRefPtr<WebCore::UserGestureToken>() const;
 #endif
 
 private:
-    WEBKIT_EXPORT void assign(const WebUserGestureToken&);
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void assign(const WebUserGestureToken&);
+    BLINK_EXPORT void reset();
 
     WebPrivatePtr<WebCore::UserGestureToken> m_token;
 };
diff --git a/public/web/WebUserMediaRequest.h b/public/web/WebUserMediaRequest.h
index 778d371..9a33d1e 100644
--- a/public/web/WebUserMediaRequest.h
+++ b/public/web/WebUserMediaRequest.h
@@ -59,25 +59,25 @@
         return *this;
     }
 
-    WEBKIT_EXPORT void reset();
+    BLINK_EXPORT void reset();
     bool isNull() const { return m_private.isNull(); }
-    WEBKIT_EXPORT bool equals(const WebUserMediaRequest&) const;
-    WEBKIT_EXPORT void assign(const WebUserMediaRequest&);
+    BLINK_EXPORT bool equals(const WebUserMediaRequest&) const;
+    BLINK_EXPORT void assign(const WebUserMediaRequest&);
 
-    WEBKIT_EXPORT bool audio() const;
-    WEBKIT_EXPORT bool video() const;
-    WEBKIT_EXPORT WebMediaConstraints audioConstraints() const;
-    WEBKIT_EXPORT WebMediaConstraints videoConstraints() const;
+    BLINK_EXPORT bool audio() const;
+    BLINK_EXPORT bool video() const;
+    BLINK_EXPORT WebMediaConstraints audioConstraints() const;
+    BLINK_EXPORT WebMediaConstraints videoConstraints() const;
 
-    WEBKIT_EXPORT WebSecurityOrigin securityOrigin() const;
-    WEBKIT_EXPORT WebDocument ownerDocument() const;
+    BLINK_EXPORT WebSecurityOrigin securityOrigin() const;
+    BLINK_EXPORT WebDocument ownerDocument() const;
 
-    WEBKIT_EXPORT void requestSucceeded(const WebMediaStream&);
+    BLINK_EXPORT void requestSucceeded(const WebMediaStream&);
 
-    WEBKIT_EXPORT void requestFailed(const WebString& description = WebString());
-    WEBKIT_EXPORT void requestFailedConstraint(const WebString& constraintName, const WebString& description = WebString());
+    BLINK_EXPORT void requestFailed(const WebString& description = WebString());
+    BLINK_EXPORT void requestFailedConstraint(const WebString& constraintName, const WebString& description = WebString());
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebUserMediaRequest(const PassRefPtr<WebCore::UserMediaRequest>&);
     WebUserMediaRequest(WebCore::UserMediaRequest*);
     operator WebCore::UserMediaRequest*() const;
diff --git a/public/web/WebValidationMessageClient.h b/public/web/WebValidationMessageClient.h
index 26a07b1..354606b 100644
--- a/public/web/WebValidationMessageClient.h
+++ b/public/web/WebValidationMessageClient.h
@@ -39,6 +39,8 @@
 struct WebRect;
 
 // Client interface to handle form validation message UI.
+// Depecated: This wil be removed when Chromium code siwtches to WebViewClient
+// functions.
 class WebValidationMessageClient {
 public:
     // Show a notification popup for the specified form vaidation messages
diff --git a/public/web/WebView.h b/public/web/WebView.h
index eaaed13..a945798 100644
--- a/public/web/WebView.h
+++ b/public/web/WebView.h
@@ -68,11 +68,11 @@
 
 class WebView : public WebWidget {
 public:
-    WEBKIT_EXPORT static const double textSizeMultiplierRatio;
-    WEBKIT_EXPORT static const double minTextSizeMultiplier;
-    WEBKIT_EXPORT static const double maxTextSizeMultiplier;
-    WEBKIT_EXPORT static const float minPageScaleFactor;
-    WEBKIT_EXPORT static const float maxPageScaleFactor;
+    BLINK_EXPORT static const double textSizeMultiplierRatio;
+    BLINK_EXPORT static const double minTextSizeMultiplier;
+    BLINK_EXPORT static const double maxTextSizeMultiplier;
+    BLINK_EXPORT static const float minPageScaleFactor;
+    BLINK_EXPORT static const float maxPageScaleFactor;
 
     // Controls which frames user content is injected into.
     enum UserContentInjectIn {
@@ -92,7 +92,7 @@
     // Creates a WebView that is NOT yet initialized.  You will need to
     // call initializeMainFrame to finish the initialization.  It is valid
     // to pass null client pointers.
-    WEBKIT_EXPORT static WebView* create(WebViewClient*);
+    BLINK_EXPORT static WebView* create(WebViewClient*);
 
     // After creating a WebView, you should immediately call this method.
     // You can optionally modify the settings before calling this method.
@@ -239,8 +239,8 @@
 
     // Helper functions to convert between zoom level and zoom factor.  zoom
     // factor is zoom percent / 100, so 300% = 3.0.
-    WEBKIT_EXPORT static double zoomLevelToZoomFactor(double zoomLevel);
-    WEBKIT_EXPORT static double zoomFactorToZoomLevel(double factor);
+    BLINK_EXPORT static double zoomLevelToZoomFactor(double zoomLevel);
+    BLINK_EXPORT static double zoomFactorToZoomLevel(double factor);
 
     // Returns the current text zoom factor, where 1.0 is the normal size, > 1.0
     // is scaled up and < 1.0 is scaled down.
@@ -443,18 +443,18 @@
     // Popup menu ----------------------------------------------------------
 
     // Sets whether select popup menus should be rendered by the browser.
-    WEBKIT_EXPORT static void setUseExternalPopupMenus(bool);
+    BLINK_EXPORT static void setUseExternalPopupMenus(bool);
 
 
     // Visited link state --------------------------------------------------
 
     // Tells all WebView instances to update the visited link state for the
     // specified hash.
-    WEBKIT_EXPORT static void updateVisitedLinkState(unsigned long long hash);
+    BLINK_EXPORT static void updateVisitedLinkState(unsigned long long hash);
 
     // Tells all WebView instances to update the visited state for all
     // their links.
-    WEBKIT_EXPORT static void resetVisitedLinkState();
+    BLINK_EXPORT static void resetVisitedLinkState();
 
 
     // Custom colors -------------------------------------------------------
@@ -469,18 +469,18 @@
                                     unsigned inactiveForegroundColor) = 0;
 
     // User scripts --------------------------------------------------------
-    WEBKIT_EXPORT static void addUserStyleSheet(const WebString& sourceCode,
+    BLINK_EXPORT static void addUserStyleSheet(const WebString& sourceCode,
                                                 const WebVector<WebString>& patterns,
                                                 UserContentInjectIn injectIn,
                                                 UserStyleInjectionTime injectionTime = UserStyleInjectInSubsequentDocuments);
-    WEBKIT_EXPORT static void removeAllUserContent();
+    BLINK_EXPORT static void removeAllUserContent();
 
     // Modal dialog support ------------------------------------------------
 
     // Call these methods before and after running a nested, modal event loop
     // to suspend script callbacks and resource loads.
-    WEBKIT_EXPORT static void willEnterModalLoop();
-    WEBKIT_EXPORT static void didExitModalLoop();
+    BLINK_EXPORT static void willEnterModalLoop();
+    BLINK_EXPORT static void didExitModalLoop();
 
     // Called to inform the WebView that a wheel fling animation was started externally (for instance
     // by the compositor) but must be completed by the WebView.
diff --git a/public/web/WebViewClient.h b/public/web/WebViewClient.h
index 2eedc03..60a3b46 100644
--- a/public/web/WebViewClient.h
+++ b/public/web/WebViewClient.h
@@ -219,6 +219,17 @@
     // true. This function is used only if ExternalDateTimeChooser is used.
     virtual bool openDateTimeChooser(const WebDateTimeChooserParams&, WebDateTimeChooserCompletion*) { return false; }
 
+    // Show a notification popup for the specified form vaidation messages
+    // besides the anchor rectangle. An implementation of this function should
+    // not hide the popup until hideValidationMessage call.
+    virtual void showValidationMessage(const WebRect& anchorInRootView, const WebString& mainText, const WebString& supplementalText, WebTextDirection hint) { }
+
+    // Hide notifation popup for form validation messages.
+    virtual void hideValidationMessage() { }
+
+    // Move the existing notifation popup to the new anchor position.
+    virtual void moveValidationMessage(const WebRect& anchorInRootView) { }
+
     // Displays a modal alert dialog containing the given message.  Returns
     // once the user dismisses the dialog.
     virtual void runModalAlertDialog(
diff --git a/public/web/WebWindowFeatures.h b/public/web/WebWindowFeatures.h
index db794a4..5df1a4d 100644
--- a/public/web/WebWindowFeatures.h
+++ b/public/web/WebWindowFeatures.h
@@ -35,7 +35,7 @@
 #include "../platform/WebString.h"
 #include "../platform/WebVector.h"
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
 #include "core/page/WindowFeatures.h"
 #endif
 
@@ -79,7 +79,7 @@
     }
 
 
-#if WEBKIT_IMPLEMENTATION
+#if BLINK_IMPLEMENTATION
     WebWindowFeatures(const WebCore::WindowFeatures& f)
         : x(f.x)
         , xSet(f.xSet)
diff --git a/public/web/WebWorkerInfo.h b/public/web/WebWorkerInfo.h
index d94b410..5b00114 100644
--- a/public/web/WebWorkerInfo.h
+++ b/public/web/WebWorkerInfo.h
@@ -37,7 +37,7 @@
 
 class WebWorkerInfo {
 public:
-    WEBKIT_EXPORT static unsigned dedicatedWorkerCount();
+    BLINK_EXPORT static unsigned dedicatedWorkerCount();
 };
 
 }
diff --git a/public/web/android/WebInputEventFactory.h b/public/web/android/WebInputEventFactory.h
index 1e8435c..7528141 100644
--- a/public/web/android/WebInputEventFactory.h
+++ b/public/web/android/WebInputEventFactory.h
@@ -53,14 +53,14 @@
         MouseWheelDirectionTypeRight,
     };
 
-    WEBKIT_EXPORT static WebKeyboardEvent keyboardEvent(WebInputEvent::Type,
+    BLINK_EXPORT static WebKeyboardEvent keyboardEvent(WebInputEvent::Type,
                                                         int modifiers,
                                                         double timeStampSeconds,
                                                         int keycode,
                                                         WebUChar unicodeCharacter,
                                                         bool isSystemKey);
 
-    WEBKIT_EXPORT static WebMouseEvent mouseEvent(MouseEventType,
+    BLINK_EXPORT static WebMouseEvent mouseEvent(MouseEventType,
                                                   WebMouseEvent::Button,
                                                   double timeStampSeconds,
                                                   int windowX,
@@ -68,12 +68,12 @@
                                                   int modifiers,
                                                   int clickCount);
 
-    WEBKIT_EXPORT static WebMouseWheelEvent mouseWheelEvent(MouseWheelDirectionType,
+    BLINK_EXPORT static WebMouseWheelEvent mouseWheelEvent(MouseWheelDirectionType,
                                                             double timeStampSeconds,
                                                             int windowX,
                                                             int windowY);
 
-    WEBKIT_EXPORT static WebGestureEvent gestureEvent(WebInputEvent::Type,
+    BLINK_EXPORT static WebGestureEvent gestureEvent(WebInputEvent::Type,
                                                       double timeStampSeconds,
                                                       int x,
                                                       int y,
@@ -81,7 +81,7 @@
                                                       float deltaY,
                                                       int modifiers);
 
-    WEBKIT_EXPORT static WebGestureEvent gestureEvent(WebInputEvent::Type,
+    BLINK_EXPORT static WebGestureEvent gestureEvent(WebInputEvent::Type,
                                                       double timeStampSeconds,
                                                       int x,
                                                       int y,
diff --git a/public/web/default/WebRenderTheme.h b/public/web/default/WebRenderTheme.h
index 48b2e6a..6a42531 100644
--- a/public/web/default/WebRenderTheme.h
+++ b/public/web/default/WebRenderTheme.h
@@ -36,7 +36,7 @@
 namespace WebKit {
 
 // Set caret blink interval for text input areas.
-WEBKIT_EXPORT void setCaretBlinkInterval(double);
+BLINK_EXPORT void setCaretBlinkInterval(double);
 
 } // namespace WebKit
 
diff --git a/public/web/gtk/WebInputEventFactory.h b/public/web/gtk/WebInputEventFactory.h
index d497a22..1f6917f 100644
--- a/public/web/gtk/WebInputEventFactory.h
+++ b/public/web/gtk/WebInputEventFactory.h
@@ -47,12 +47,12 @@
 
 class WebInputEventFactory {
 public:
-    WEBKIT_EXPORT static WebKeyboardEvent keyboardEvent(const GdkEventKey*);
-    WEBKIT_EXPORT static WebKeyboardEvent keyboardEvent(wchar_t character, int state, double timeStampSeconds);
-    WEBKIT_EXPORT static WebMouseEvent mouseEvent(const GdkEventButton*);
-    WEBKIT_EXPORT static WebMouseEvent mouseEvent(const GdkEventMotion*);
-    WEBKIT_EXPORT static WebMouseEvent mouseEvent(const GdkEventCrossing*);
-    WEBKIT_EXPORT static WebMouseWheelEvent mouseWheelEvent(const GdkEventScroll*);
+    BLINK_EXPORT static WebKeyboardEvent keyboardEvent(const GdkEventKey*);
+    BLINK_EXPORT static WebKeyboardEvent keyboardEvent(wchar_t character, int state, double timeStampSeconds);
+    BLINK_EXPORT static WebMouseEvent mouseEvent(const GdkEventButton*);
+    BLINK_EXPORT static WebMouseEvent mouseEvent(const GdkEventMotion*);
+    BLINK_EXPORT static WebMouseEvent mouseEvent(const GdkEventCrossing*);
+    BLINK_EXPORT static WebMouseWheelEvent mouseWheelEvent(const GdkEventScroll*);
 };
 
 } // namespace WebKit
diff --git a/public/web/linux/WebFontRendering.h b/public/web/linux/WebFontRendering.h
index 8903924..27ff94f 100644
--- a/public/web/linux/WebFontRendering.h
+++ b/public/web/linux/WebFontRendering.h
@@ -41,14 +41,14 @@
 public:
     // Set global font renderering preferences.
 
-    WEBKIT_EXPORT static void setHinting(SkPaint::Hinting);
-    WEBKIT_EXPORT static void setAutoHint(bool);
-    WEBKIT_EXPORT static void setUseBitmaps(bool);
-    WEBKIT_EXPORT static void setAntiAlias(bool);
-    WEBKIT_EXPORT static void setSubpixelRendering(bool);
-    WEBKIT_EXPORT static void setSubpixelPositioning(bool);
-    WEBKIT_EXPORT static void setLCDOrder(SkFontHost::LCDOrder);
-    WEBKIT_EXPORT static void setLCDOrientation(SkFontHost::LCDOrientation);
+    BLINK_EXPORT static void setHinting(SkPaint::Hinting);
+    BLINK_EXPORT static void setAutoHint(bool);
+    BLINK_EXPORT static void setUseBitmaps(bool);
+    BLINK_EXPORT static void setAntiAlias(bool);
+    BLINK_EXPORT static void setSubpixelRendering(bool);
+    BLINK_EXPORT static void setSubpixelPositioning(bool);
+    BLINK_EXPORT static void setLCDOrder(SkFontHost::LCDOrder);
+    BLINK_EXPORT static void setLCDOrientation(SkFontHost::LCDOrientation);
 };
 
 } // namespace WebKit
diff --git a/public/web/mac/WebInputEventFactory.h b/public/web/mac/WebInputEventFactory.h
index e153997..2a2ae1f 100644
--- a/public/web/mac/WebInputEventFactory.h
+++ b/public/web/mac/WebInputEventFactory.h
@@ -50,11 +50,11 @@
 
 class WebInputEventFactory {
 public:
-    WEBKIT_EXPORT static WebKeyboardEvent keyboardEvent(NSEvent*);
-    WEBKIT_EXPORT static WebKeyboardEvent keyboardEvent(wchar_t character, int modifiers, double timeStampSeconds);
-    WEBKIT_EXPORT static WebMouseEvent mouseEvent(NSEvent*, NSView*);
-    WEBKIT_EXPORT static WebMouseWheelEvent mouseWheelEvent(NSEvent*, NSView*);
-    WEBKIT_EXPORT static WebGestureEvent gestureEvent(NSEvent *, NSView *);
+    BLINK_EXPORT static WebKeyboardEvent keyboardEvent(NSEvent*);
+    BLINK_EXPORT static WebKeyboardEvent keyboardEvent(wchar_t character, int modifiers, double timeStampSeconds);
+    BLINK_EXPORT static WebMouseEvent mouseEvent(NSEvent*, NSView*);
+    BLINK_EXPORT static WebMouseWheelEvent mouseWheelEvent(NSEvent*, NSView*);
+    BLINK_EXPORT static WebGestureEvent gestureEvent(NSEvent *, NSView *);
 };
 
 } // namespace WebKit
diff --git a/public/web/mac/WebSubstringUtil.h b/public/web/mac/WebSubstringUtil.h
index 14f3c99..e550481 100644
--- a/public/web/mac/WebSubstringUtil.h
+++ b/public/web/mac/WebSubstringUtil.h
@@ -49,7 +49,7 @@
 public:
     // Returns an autoreleased NSAttributedString that is a substring of the
     // Frame at the given range, or nil on error.
-    WEBKIT_EXPORT static NSAttributedString* attributedSubstringInRange(WebFrame*,
+    BLINK_EXPORT static NSAttributedString* attributedSubstringInRange(WebFrame*,
         size_t location,
         size_t length);
 };
diff --git a/public/web/win/WebInputEventFactory.h b/public/web/win/WebInputEventFactory.h
index 620216a..329b06d 100644
--- a/public/web/win/WebInputEventFactory.h
+++ b/public/web/win/WebInputEventFactory.h
@@ -43,9 +43,9 @@
 
 class WebInputEventFactory {
 public:
-    WEBKIT_EXPORT static WebKeyboardEvent keyboardEvent(HWND, UINT, WPARAM, LPARAM);
-    WEBKIT_EXPORT static WebMouseEvent mouseEvent(HWND, UINT, WPARAM, LPARAM);
-    WEBKIT_EXPORT static WebMouseWheelEvent mouseWheelEvent(HWND, UINT, WPARAM, LPARAM);
+    BLINK_EXPORT static WebKeyboardEvent keyboardEvent(HWND, UINT, WPARAM, LPARAM);
+    BLINK_EXPORT static WebMouseEvent mouseEvent(HWND, UINT, WPARAM, LPARAM);
+    BLINK_EXPORT static WebMouseWheelEvent mouseWheelEvent(HWND, UINT, WPARAM, LPARAM);
 
     // Windows only provides information on whether a click was a single or
     // double click, while we need to know the click count past two. The
@@ -53,7 +53,7 @@
     // that information. In some cases, like fast-running tests, that
     // information is known to be stale and needs to be reset; that is the
     // function of resetLastClickState().
-    WEBKIT_EXPORT static void resetLastClickState();
+    BLINK_EXPORT static void resetLastClickState();
 };
 
 } // namespace WebKit