Implement chrome.downloads.onDeterminingFilename()

chrome/browser/extensions/api/downloads/downloads_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
 
 #include <algorithm>
 #include <cctype>
 #include <iterator>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
@@ skipping 146 matching lines @@
 DownloadItem::DownloadState StateEnumFromString(const std::string& state) {
   for (size_t i = 0; i < arraysize(kStateStrings); ++i) {
     if ((kStateStrings[i] != NULL) && (state == kStateStrings[i]))
       return static_cast<DownloadItem::DownloadState>(i);
   }
   return DownloadItem::MAX_DOWNLOAD_STATE;
 }
 
 bool ValidateFilename(const string16& filename) {
   // TODO(benjhayden): More robust validation of filename.
+  if (filename.size() < 1)

[battre, 2013/01/11 14:29:37]

nit: why not
if (filename.empty())
?

[benjhayden, 2013/01/11 21:21:27]

Done.

+    return false;
   if ((filename.find('/') != string16::npos) ||
       (filename.find('\\') != string16::npos))
     return false;
   if (filename.size() >= 2u && filename[0] == L'.' && filename[1] == L'.')
     return false;
   return true;
 }
 
 std::string TimeToISO8601(const base::Time& t) {
   base::Time::Exploded exploded;
@@ skipping 56 matching lines @@
 };
 
 bool DownloadFileIconExtractorImpl::ExtractIconURLForPath(
     const FilePath& path,
     IconLoader::IconSize icon_size,
     IconURLCallback callback) {
   callback_ = callback;
   IconManager* im = g_browser_process->icon_manager();
   // The contents of the file at |path| may have changed since a previous
   // request, in which case the associated icon may also have changed.
-  // Therefore, for the moment we always call LoadIcon instead of attempting
-  // a LookupIcon.
+  // Therefore, always call LoadIcon instead of attempting a LookupIcon.
   im->LoadIcon(path,
                icon_size,
                base::Bind(&DownloadFileIconExtractorImpl::OnIconLoadComplete,
                           base::Unretained(this)),
                &cancelable_task_tracker_);
   return true;
 }
 
 void DownloadFileIconExtractorImpl::OnIconLoadComplete(gfx::Image* icon) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 258 matching lines @@
     base::SupportsUserData::Data* data = download_item->GetUserData(kKey);
     return (data == NULL) ? NULL :
         static_cast<ExtensionDownloadsEventRouterData*>(data);
   }
 
   explicit ExtensionDownloadsEventRouterData(
       DownloadItem* download_item,
       scoped_ptr<base::DictionaryValue> json_item)
       : updated_(0),
         changed_fired_(0),
-        json_(json_item.Pass()) {
+        json_(json_item.Pass()),
+        determined_overwrite_(false) {
     download_item->SetUserData(kKey, this);
   }
 
   virtual ~ExtensionDownloadsEventRouterData() {
     if (updated_ > 0) {
       UMA_HISTOGRAM_PERCENTAGE("Download.OnChanged",
                                (changed_fired_ * 100 / updated_));
     }
   }
 
   const base::DictionaryValue& json() const { return *json_.get(); }
   void set_json(scoped_ptr<base::DictionaryValue> json_item) {
     json_ = json_item.Pass();
   }
 
   void OnItemUpdated() { ++updated_; }
   void OnChangedFired() { ++changed_fired_; }
 
+  void set_filename_change_callbacks(
+      const base::Closure& no_change,
+      const ExtensionDownloadsEventRouter::FilenameChangedCallback& change) {
+    filename_no_change_ = no_change;
+    filename_change_ = change;
+  }
+
+  void AddDeterminer(const std::string& determiner_id) {

[battre, 2013/01/11 14:29:37]

How about "AddPendingDeterminer"?

[benjhayden, 2013/01/11 21:21:27]

Done.

+    DCHECK(determiners_.insert(determiner_id).second);
+  }
+
+  bool DetermineFilename(

[battre, 2013/01/11 14:29:37]

How about "DeterminerCallback"

[benjhayden, 2013/01/11 21:21:27]

Done.

+      const std::string& determiner_id,
+      const FilePath& filename,
+      bool overwrite) {
+    DeterminerSet::iterator iter = determiners_.find(determiner_id);
+    if (iter == determiners_.end())
+      return false;
+    determiners_.erase(iter);

[battre, 2013/01/11 14:29:37]

This looks strange. DetermineFilename should not modify the object |this| based
on my judgement of the filename. As mentioned in download_api_internal.cc I
think that "DetermineFilename" is not a good name.

[benjhayden, 2013/01/11 21:21:27]

This is the method that runs when any onDeterminingFilename listener returns.
When called in response to the *last* listener returning, it needs to call
either filename_no_change_ or filename_change_.
I changed this method to detect the last listener using a flag for each
listener.
Is there a better way to detect when the last listener has returned?

+    if (!filename.empty() && !filename.IsAbsolute()) {
+      determined_filename_ = filename;
+      determined_overwrite_ = overwrite;
+    }
+    if (determiners_.empty()) {
+      if (determined_filename_.empty()) {
+        filename_no_change_.Run();
+      } else {
+        filename_change_.Run(determined_filename_, determined_overwrite_);
+      }
+    }

[battre, 2013/01/11 14:29:37]

This is "Last callback wins" semantic. In the WebRequest API we tried to be sure
to be deterministic by enforcing that the last installed extension that wants to
modify the request takes precedence.

[benjhayden, 2013/01/11 21:21:27]

Done.

+    return true;
+  }
+
  private:
+  typedef std::set<std::string> DeterminerSet;
+
   static const char kKey[];
 
   int updated_;
   int changed_fired_;
   scoped_ptr<base::DictionaryValue> json_;
+  base::Closure filename_no_change_;
+  ExtensionDownloadsEventRouter::FilenameChangedCallback filename_change_;
+  FilePath determined_filename_;
+  bool determined_overwrite_;
+  DeterminerSet determiners_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDownloadsEventRouterData);
 };
 
 const char ExtensionDownloadsEventRouterData::kKey[] =
   "DownloadItem ExtensionDownloadsEventRouterData";
 
 }  // namespace
 
 DownloadsDownloadFunction::DownloadsDownloadFunction() {}
@@ skipping 158 matching lines @@
       extensions::api::downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownloadIfInProgress(
       profile(), include_incognito(), params->download_id);
   if (download_item == NULL) {
     // This could be due to an invalid download ID, or it could be due to the
     // download not being currently active.
     error_ = download_extension_errors::kInvalidOperationError;
   } else {
     // Note that if the item isn't paused, this will be a no-op, and
-    // we will silently treat the extension call as a success.
+    // the extension call will seem successful.
     download_item->Resume();
   }
   if (error_.empty())
     RecordApiFunctions(DOWNLOADS_FUNCTION_RESUME);
   return error_.empty();
 }
 
 DownloadsCancelFunction::DownloadsCancelFunction() {}
 DownloadsCancelFunction::~DownloadsCancelFunction() {}
 
 bool DownloadsCancelFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Resume::Params> params(
       extensions::api::downloads::Resume::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   DownloadItem* download_item = GetDownloadIfInProgress(
       profile(), include_incognito(), params->download_id);
   if (download_item != NULL)
     download_item->Cancel(true);
   // |download_item| can be NULL if the download ID was invalid or if the
-  // download is not currently active.  Either way, we don't consider it a
-  // failure.
+  // download is not currently active.  Either way, it's not a failure.
   RecordApiFunctions(DOWNLOADS_FUNCTION_CANCEL);
   return true;
 }
 
 DownloadsEraseFunction::DownloadsEraseFunction() {}
 DownloadsEraseFunction::~DownloadsEraseFunction() {}
 
 bool DownloadsEraseFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::Erase::Params> params(
       extensions::api::downloads::Erase::Params::Create(*args_));
@@ skipping 13 matching lines @@
   for (DownloadManager::DownloadVector::const_iterator it = results.begin();
        it != results.end(); ++it) {
     json_results->Append(base::Value::CreateIntegerValue((*it)->GetId()));
     (*it)->Remove();
   }
   SetResult(json_results);
   RecordApiFunctions(DOWNLOADS_FUNCTION_ERASE);
   return true;
 }
 
-DownloadsSetDestinationFunction::DownloadsSetDestinationFunction() {}
-DownloadsSetDestinationFunction::~DownloadsSetDestinationFunction() {}
-
-bool DownloadsSetDestinationFunction::RunImpl() {
-  scoped_ptr<extensions::api::downloads::SetDestination::Params> params(
-      extensions::api::downloads::SetDestination::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-  error_ = download_extension_errors::kNotImplementedError;
-  if (error_.empty())
-    RecordApiFunctions(DOWNLOADS_FUNCTION_SET_DESTINATION);
-  return error_.empty();
-}
-
 DownloadsAcceptDangerFunction::DownloadsAcceptDangerFunction() {}
 DownloadsAcceptDangerFunction::~DownloadsAcceptDangerFunction() {}
 
 bool DownloadsAcceptDangerFunction::RunImpl() {
   scoped_ptr<extensions::api::downloads::AcceptDanger::Params> params(
       extensions::api::downloads::AcceptDanger::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   error_ = download_extension_errors::kNotImplementedError;
   if (error_.empty())
     RecordApiFunctions(DOWNLOADS_FUNCTION_ACCEPT_DANGER);
@@ skipping 84 matching lines @@
   int icon_size = kDefaultIconSize;
   if (options && options->size.get())
     icon_size = *options->size.get();
   DownloadItem* download_item = GetDownload(
       profile(), include_incognito(), params->download_id);
   if (!download_item || download_item->GetTargetFilePath().empty()) {
     error_ = download_extension_errors::kInvalidOperationError;
     return false;
   }
   // In-progress downloads return the intermediate filename for GetFullPath()
-  // which doesn't have the final extension. Therefore we won't be able to
-  // derive a good file icon for it. So we use GetTargetFilePath() instead.
+  // which doesn't have the final extension. Therefore a good file icon can't be
+  // found, so use GetTargetFilePath() instead.
   DCHECK(icon_extractor_.get());
   DCHECK(icon_size == 16 || icon_size == 32);
   EXTENSION_FUNCTION_VALIDATE(icon_extractor_->ExtractIconURLForPath(
       download_item->GetTargetFilePath(),
       IconLoaderSizeFromPixelSize(icon_size),
       base::Bind(&DownloadsGetFileIconFunction::OnIconURLExtracted, this)));
   return true;
 }
 
 void DownloadsGetFileIconFunction::OnIconURLExtracted(const std::string& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (url.empty()) {
     error_ = download_extension_errors::kIconNotFoundError;
   } else {
     RecordApiFunctions(DOWNLOADS_FUNCTION_GET_FILE_ICON);
     SetResult(base::Value::CreateStringValue(url));
   }
   SendResponse(error_.empty());
 }
 
+// The method by which extensions hook into the filename determination process
+// is based on the method by which the webRequest API allows extensions to hook
+// into the resource loading process.  Extensions that wish to play a part in
+// the filename determination process call
+// chrome.downloads.onDeterminingFilename.addListener, which secretly (see
+// chrome/renderer/resources/extensions/downloads_custom_bindings.js) calls
+// DownloadsInternalAddFilenameDeterminerFunction (see ../downloads_internal/),
+// which adds the extension's ID to the profile's ExtensionDownloadsEventRouter
+// (EDER).  When a download's filename is being determined,
+// ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone (CVRBD) passes
+// 2 callbacks to EDER::OnDownloadFilenameDetermined (ODFD), which stores the
+// callbacks in the item's ExtensionDownloadsEventRouterData (EDERD) along with
+// all of the extension IDs that are listening for onDeterminingFilename events.
+// ODFD dispatches chrome.downloads.onDeterminingFilename. When the extension's
+// event handler returns, downloads_custom_bindings.js calls
+// DownloadsInternalDetermineFilenameFunction::RunImpl, which notifies the
+// item's EDERD.  When the last extension's event handler returns, EDERD calls
+// one of the two callbacks that CVRBD passed to ODFD, allowing CDMD to complete
+// the filename determination process. If multiple extensions wish to override
+// the filename, then the last one wins. However, there's no deterministic way
+// to determine which extension will finish last, so users are advised to try to

[vabr (Chromium), 2013/01/11 12:43:40]

How precisely are the users advised? Using the ExtensionWarning class?

[benjhayden, 2013/01/11 21:21:27]

Oh, I was just going to make a note in downloads.idl, the developer
documentation.
ExtensionWarning says it puts a badge on the hotdog menu. I don't know if this
situation is severe enough to bug users like that.

[vabr (Chromium), 2013/01/15 08:19:22]

The analogy in WebRequest is, e.g., when two extension give conflicting redirect
instructions (see
https://cs.corp.google.com/#chrome/src/chrome/browser/extensions/api/web_requ...).
There the ExtensionWarning is used, and I think that might justify using it for
clashing download renaming. From the user's point of view, the results of two
conflicting extensions doing download renaming might be rather confusing, and we
can't really expect them to read the developers' docs.
Also, if it was fairly improbable for two extensions to clash on download
renaming, then that would be one more reason to use ExtensionWarning and not to
worry about its severity.

However, I don't feel strongly about this. If Dominic, or another reviewer
knowledgeable in extensions, is OK with emitting no warning, then I'm fine with
that as well.

[battre, 2013/01/15 09:00:40]

Please don't add a warning badge for this. I think that is too intrusive. We
introduced the warning badge because the WebRequest API commands can be critical
for privacy/security reasons (e.g. deleting headers that disguise your
identity).

+// use extensions that won't conflict.
+
+bool ExtensionDownloadsEventRouter::AddFilenameDeterminer(
+    Profile* profile,
+    bool include_incognito,
+    const std::string& ext_id,
+    const std::string& determiner_id) {
+  if (include_incognito && profile->HasOffTheRecordProfile()) {
+    AddFilenameDeterminer(profile->GetOffTheRecordProfile(),
+                          false,
+                          ext_id,
+                          determiner_id);
+  }
+  ExtensionDownloadsEventRouter* router =
+    DownloadServiceFactory::GetForProfile(profile)->GetExtensionEventRouter();

[vabr (Chromium), 2013/01/11 12:43:40]

+2 spaces of indentation

[benjhayden, 2013/01/11 21:21:27]

Done.

+  return router->filename_determiners_[determiner_id].insert(ext_id).second;
+}
+
+bool ExtensionDownloadsEventRouter::RemoveFilenameDeterminer(
+    Profile* profile,
+    bool include_incognito,
+    const std::string& ext_id,
+    const std::string& determiner_id) {
+  if (include_incognito && profile->HasOffTheRecordProfile()) {
+    RemoveFilenameDeterminer(profile->GetOffTheRecordProfile(),
+                             false,
+                             ext_id,
+                             determiner_id);
+  }
+  ExtensionDownloadsEventRouter* router =
+    DownloadServiceFactory::GetForProfile(profile)->GetExtensionEventRouter();

[vabr (Chromium), 2013/01/11 12:43:40]

+2 spaces of indentation

[benjhayden, 2013/01/11 21:21:27]

Done.

+  DeterminerMap::iterator determiner_entry(
+      router->filename_determiners_.find(determiner_id));
+  DCHECK(determiner_entry != router->filename_determiners_.end());
+  if (determiner_entry == router->filename_determiners_.end())
+    return false;
+  ExtensionIdSet::iterator extension_entry(
+      router->filename_determiners_[determiner_id].find(ext_id));
+  DCHECK(extension_entry != router->filename_determiners_[determiner_id].end());
+  if (extension_entry == router->filename_determiners_[determiner_id].end())
+    return false;
+  router->filename_determiners_[determiner_id].erase(extension_entry);
+  if (router->filename_determiners_[determiner_id].empty())
+    router->filename_determiners_.erase(determiner_entry);
+  return true;
+}
+
+bool ExtensionDownloadsEventRouter::DetermineFilename(
+    Profile* profile,
+    bool include_incognito,
+    const std::string& ext_id,
+    const std::string& determiner_id,
+    int download_id,
+    const FilePath& filename,
+    bool overwrite) {
+  DownloadItem* item = GetDownloadIfInProgress(
+      profile, include_incognito, download_id);
+  if (!item)
+    return false;
+  ExtensionDownloadsEventRouterData* data =
+    ExtensionDownloadsEventRouterData::Get(item);

[vabr (Chromium), 2013/01/11 12:43:40]

+2 spaces of indentation

[benjhayden, 2013/01/11 21:21:27]

Done.

+  if (!data)
+    return false;
+  return data->DetermineFilename(
+      ext_id + "-" + determiner_id, filename, overwrite);
+}
+
 ExtensionDownloadsEventRouter::ExtensionDownloadsEventRouter(
     Profile* profile,
     DownloadManager* manager)
     : profile_(profile),
       ALLOW_THIS_IN_INITIALIZER_LIST(notifier_(manager, this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(profile_);
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::Source<Profile>(profile_));
+}
+
+void ExtensionDownloadsEventRouter::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      const extensions::Extension* extension = content::Details<
+        extensions::UnloadedExtensionInfo>(details)->extension;

[vabr (Chromium), 2013/01/11 12:43:40]

+2 spaces of indent

[benjhayden, 2013/01/11 21:21:27]

Done.

+      std::set<std::string> empty_determiners;
+      for (DeterminerMap::iterator
+           determiner_iter = filename_determiners_.begin();
+           determiner_iter != filename_determiners_.end();
+           ++determiner_iter) {
+        ExtensionIdSet::iterator found(determiner_iter->second.find(
+            extension->id()));
+        if (found != determiner_iter->second.end()) {
+          determiner_iter->second.erase(found);
+          if (determiner_iter->second.empty())
+            empty_determiners.insert(determiner_iter->first);
+        }
+      }
+      for (std::set<std::string>::const_iterator
+           iter = empty_determiners.begin();

[vabr (Chromium), 2013/01/11 12:43:40]

+4 spaces of indent
nit: please break after "=", not before "iter"

[benjhayden, 2013/01/11 21:21:27]

Done.

+           iter != empty_determiners.end();
+           ++iter) {
+        DeterminerMap::iterator found = filename_determiners_.find(*iter);
+        CHECK(found != filename_determiners_.end());
+        filename_determiners_.erase(found);
+      }
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
+  }
 }
 
 ExtensionDownloadsEventRouter::~ExtensionDownloadsEventRouter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadCreated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
 
   scoped_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item, profile_->IsOffTheRecord()));
   DispatchEvent(extensions::event_names::kOnDownloadCreated,
                 json_item->DeepCopy());
   if (!ExtensionDownloadsEventRouterData::Get(download_item))
     new ExtensionDownloadsEventRouterData(download_item, json_item.Pass());
 }
 
+void ExtensionDownloadsEventRouter::OnDownloadFilenameDetermined(
+    DownloadItem* item,
+    const FilePath& suggested_path,
+    const base::Closure& no_change,
+    const FilenameChangedCallback& change) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (filename_determiners_.empty()) {
+    no_change.Run();
+    return;
+  }
+
+  ExtensionDownloadsEventRouterData* data =
+    ExtensionDownloadsEventRouterData::Get(item);

[vabr (Chromium), 2013/01/11 12:43:40]

+2 spaces of indent

[benjhayden, 2013/01/11 21:21:27]

Done.

+  data->set_filename_change_callbacks(no_change, change);
+  std::string event_name(
+      extensions::event_names::kOnDownloadDeterminingFilename);
+  event_name += "/";
+  for (DeterminerMap::const_iterator
+       determiner_iter = filename_determiners_.begin();

[vabr (Chromium), 2013/01/11 12:43:40]

+4 spaces
nit: please break after "="

[benjhayden, 2013/01/11 21:21:27]

Done.

+       determiner_iter != filename_determiners_.end();
+       ++determiner_iter) {
+    const std::string& determiner_id = determiner_iter->first;
+    for (ExtensionIdSet::const_iterator
+         ext_iter = determiner_iter->second.begin();
+         ext_iter != determiner_iter->second.end();
+         ++ext_iter) {
+      data->AddDeterminer((*ext_iter) + "-" + determiner_id);
+    }
+    base::DictionaryValue* json = DownloadItemToJSON(
+        item, profile_->IsOffTheRecord()).release();
+    json->SetString(
+        kFilenameKey, suggested_path.LossyDisplayName());
+    DispatchEvent(
+        (event_name + determiner_id).c_str(),
+        json);
+  }
+}
+
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsTemporary())
     return;
 
   ExtensionDownloadsEventRouterData* data =
     ExtensionDownloadsEventRouterData::Get(download_item);
   if (!data) {
     // The download_item probably transitioned from temporary to not temporary.
@@ skipping 59 matching lines @@
 void ExtensionDownloadsEventRouter::DispatchEvent(
     const char* event_name, base::Value* arg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   std::string json_args;
   base::JSONWriter::Write(args.get(), &json_args);
   // There is a one EDER for each on-record Profile, and a separate EDER for
   // each off-record Profile, so there is exactly one EDER for each
   // DownloadManager.  EDER only watches its own DM, so all the items that an
-  // EDER sees are either all on-record or all off-record. However, we want
-  // extensions in off-record contexts to see on-record items. So, if this EDER
-  // is watching an on-record DM, and there is a corresponding off-record
-  // Profile, then dispatch this event to both the on-record Profile and the
-  // off-record Profile.  There may or may not be an off-record Profile, so send
-  // a *copy* of |args| to the off-record Profile, and Pass() |args|
-  // to the Profile that we know is there.
+  // EDER sees are either all on-record or all off-record. However, extensions
+  // in off-record contexts should see on-record items. So, if this EDER is
+  // watching an on-record DM, and there is a corresponding off-record Profile,
+  // then dispatch this event to both the on-record Profile and the off-record
+  // Profile.  There may or may not be an off-record Profile, so send a *copy*
+  // of |args| to the off-record Profile, and Pass() |args| to the Profile that
+  // is certainly there.
   if (profile_->HasOffTheRecordProfile() &&
       !profile_->IsOffTheRecord()) {
     DispatchEventInternal(
         profile_->GetOffTheRecordProfile(),
         event_name,
         json_args,
         scoped_ptr<base::ListValue>(args->DeepCopy()));
   }
   DispatchEventInternal(profile_, event_name, json_args, args.Pass());
 }