diff --git a/media/libmediaplayerservice/nuplayer/HTTPLiveSource.cpp b/media/libmediaplayerservice/nuplayer/HTTPLiveSource.cpp
index d07ea1b..576a850 100644
--- a/media/libmediaplayerservice/nuplayer/HTTPLiveSource.cpp
+++ b/media/libmediaplayerservice/nuplayer/HTTPLiveSource.cpp
@@ -33,11 +33,25 @@
 
 namespace android {
 
-NuPlayer::HTTPLiveSource::HTTPLiveSource(const char *url, uint32_t flags)
+NuPlayer::HTTPLiveSource::HTTPLiveSource(
+        const char *url,
+        const KeyedVector<String8, String8> *headers)
     : mURL(url),
-      mFlags(flags),
+      mFlags(0),
       mEOS(false),
       mOffset(0) {
+    if (headers) {
+        mExtraHeaders = *headers;
+
+        ssize_t index =
+            mExtraHeaders.indexOfKey(String8("x-hide-urls-from-log"));
+
+        if (index >= 0) {
+            mFlags |= kFlagIncognito;
+
+            mExtraHeaders.removeItemsAt(index);
+        }
+    }
 }
 
 NuPlayer::HTTPLiveSource::~HTTPLiveSource() {
@@ -55,7 +69,8 @@
 
     mLiveLooper->registerHandler(mLiveSession);
 
-    mLiveSession->connect(mURL.c_str());
+    mLiveSession->connect(
+            mURL.c_str(), mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
 
     mTSParser = new ATSParser;
 }
diff --git a/media/libmediaplayerservice/nuplayer/HTTPLiveSource.h b/media/libmediaplayerservice/nuplayer/HTTPLiveSource.h
index a8ce7f4..7a337e9 100644
--- a/media/libmediaplayerservice/nuplayer/HTTPLiveSource.h
+++ b/media/libmediaplayerservice/nuplayer/HTTPLiveSource.h
@@ -27,11 +27,9 @@
 struct LiveSession;
 
 struct NuPlayer::HTTPLiveSource : public NuPlayer::Source {
-    enum Flags {
-        // Don't log any URLs.
-        kFlagIncognito = 1,
-    };
-    HTTPLiveSource(const char *url, uint32_t flags = 0);
+    HTTPLiveSource(
+            const char *url,
+            const KeyedVector<String8, String8> *headers);
 
     virtual void start();
 
@@ -49,7 +47,13 @@
     virtual ~HTTPLiveSource();
 
 private:
+    enum Flags {
+        // Don't log any URLs.
+        kFlagIncognito = 1,
+    };
+
     AString mURL;
+    KeyedVector<String8, String8> mExtraHeaders;
     uint32_t mFlags;
     bool mEOS;
     off64_t mOffset;
diff --git a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
index d439f6e..effa703 100644
--- a/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
+++ b/media/libmediaplayerservice/nuplayer/NuPlayer.cpp
@@ -72,17 +72,7 @@
         const char *url, const KeyedVector<String8, String8> *headers) {
     sp<AMessage> msg = new AMessage(kWhatSetDataSource, id());
 
-    uint32_t flags = 0;
-
-    if (headers) {
-        ssize_t index = headers->indexOfKey(String8("x-hide-urls-from-log"));
-
-        if (index >= 0) {
-            flags |= HTTPLiveSource::kFlagIncognito;
-        }
-    }
-
-    msg->setObject("source", new HTTPLiveSource(url, flags));
+    msg->setObject("source", new HTTPLiveSource(url, headers));
     msg->post();
 }
 
diff --git a/media/libstagefright/httplive/LiveSession.cpp b/media/libstagefright/httplive/LiveSession.cpp
index 8e1bdf3..012d9ad 100644
--- a/media/libstagefright/httplive/LiveSession.cpp
+++ b/media/libstagefright/httplive/LiveSession.cpp
@@ -67,9 +67,17 @@
     return mDataSource;
 }
 
-void LiveSession::connect(const char *url) {
+void LiveSession::connect(
+        const char *url, const KeyedVector<String8, String8> *headers) {
     sp<AMessage> msg = new AMessage(kWhatConnect, id());
     msg->setString("url", url);
+
+    if (headers != NULL) {
+        msg->setPointer(
+                "headers",
+                new KeyedVector<String8, String8>(*headers));
+    }
+
     msg->post();
 }
 
@@ -144,6 +152,16 @@
     AString url;
     CHECK(msg->findString("url", &url));
 
+    KeyedVector<String8, String8> *headers = NULL;
+    if (!msg->findPointer("headers", (void **)&headers)) {
+        mExtraHeaders.clear();
+    } else {
+        mExtraHeaders = *headers;
+
+        delete headers;
+        headers = NULL;
+    }
+
     if (!(mFlags & kFlagIncognito)) {
         LOGI("onConnect '%s'", url.c_str());
     } else {
@@ -210,7 +228,8 @@
             }
         }
 
-        status_t err = mHTTPDataSource->connect(url);
+        status_t err = mHTTPDataSource->connect(
+                url, mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
 
         if (err != OK) {
             return err;
diff --git a/media/libstagefright/include/LiveSession.h b/media/libstagefright/include/LiveSession.h
index 2b5ea0e..99abe64 100644
--- a/media/libstagefright/include/LiveSession.h
+++ b/media/libstagefright/include/LiveSession.h
@@ -20,6 +20,8 @@
 
 #include <media/stagefright/foundation/AHandler.h>
 
+#include <utils/String8.h>
+
 namespace android {
 
 struct ABuffer;
@@ -37,7 +39,10 @@
 
     sp<DataSource> getDataSource();
 
-    void connect(const char *url);
+    void connect(
+            const char *url,
+            const KeyedVector<String8, String8> *headers = NULL);
+
     void disconnect();
 
     // Blocks until seek is complete.
@@ -78,6 +83,8 @@
     sp<HTTPBase> mHTTPDataSource;
 
     AString mMasterURL;
+    KeyedVector<String8, String8> mExtraHeaders;
+
     Vector<BandwidthItem> mBandwidthItems;
 
     KeyedVector<AString, sp<ABuffer> > mAESKeyForURI;
