DataTransfer: Make |types| be a FrozenArray<DOMString>.

third_party/WebKit/Source/core/clipboard/DataObject.cpp

 /*
  * Copyright (c) 2008, 2009, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 72 matching lines @@
 DataObjectItem* DataObject::Item(unsigned long index) {
   if (index >= length())
     return nullptr;
   return item_list_[index];
 }
 
 void DataObject::DeleteItem(unsigned long index) {
   if (index >= length())
     return;
   item_list_.erase(index);
+  NotifyItemListChanged();
 }
 
 void DataObject::ClearAll() {
+  const size_t old_length = item_list_.size();

[jsbell, 2017/05/15 20:49:28]

We don't care about the size specifically, just that it was non-empty?

How about making this an early return instead, i.e. `if (item_list_.isEmpty())
return;` or wrap the work in `if (!item_list_.isEmpty()) { ... }` ?

[Raphael Kubo da Costa (rakuco), 2017/05/16 08:51:51]

Done.

   item_list_.clear();
+  if (old_length != item_list_.size())
+    NotifyItemListChanged();
 }
 
 DataObjectItem* DataObject::Add(const String& data, const String& type) {
   DataObjectItem* item = DataObjectItem::CreateFromString(type, data);
   if (!InternalAddStringItem(item))
     return nullptr;
   return item;
 }
 
 DataObjectItem* DataObject::Add(File* file) {
@@ skipping 14 matching lines @@
   InternalAddFileItem(item);
   return item;
 }
 
 void DataObject::ClearData(const String& type) {
   for (size_t i = 0; i < item_list_.size(); ++i) {
     if (item_list_[i]->Kind() == DataObjectItem::kStringKind &&
         item_list_[i]->GetType() == type) {
       // Per the spec, type must be unique among all items of kind 'string'.
       item_list_.erase(i);
+      NotifyItemListChanged();
       return;
     }
   }
 }
 
 Vector<String> DataObject::Types() const {
   Vector<String> results;
 #if DCHECK_IS_ON()
   HashSet<String> types_seen;
 #endif
@@ skipping 25 matching lines @@
   for (size_t i = 0; i < item_list_.size(); ++i) {
     if (item_list_[i]->Kind() == DataObjectItem::kStringKind &&
         item_list_[i]->GetType() == type)
       return item_list_[i]->GetAsString();
   }
   return String();
 }
 
 void DataObject::SetData(const String& type, const String& data) {
   ClearData(type);
   if (!Add(data, type))

[jsbell, 2017/05/15 20:49:28]

We'll get two calls to NotifyItemListChanged() for each call to SetData(), which
seems fine. Calling it out in case we maybe want to mention that in the header.
Probably not worth it.

[Raphael Kubo da Costa (rakuco), 2017/05/16 08:51:51]

It doesn't hurt either, so I've added a small comment to OnItemListChanged() in
the header.

     NOTREACHED();
 }
 
 void DataObject::UrlAndTitle(String& url, String* title) const {
   DataObjectItem* item = FindStringItem(kMimeTypeTextURIList);
   if (!item)
     return;
   url = ConvertURIListToURL(item->GetAsString());
   if (title)
     *title = item->Title();
@@ skipping 62 matching lines @@
 
 bool DataObject::InternalAddStringItem(DataObjectItem* item) {
   ASSERT(item->Kind() == DataObjectItem::kStringKind);
   for (size_t i = 0; i < item_list_.size(); ++i) {
     if (item_list_[i]->Kind() == DataObjectItem::kStringKind &&
         item_list_[i]->GetType() == item->GetType())
       return false;
   }
 
   item_list_.push_back(item);
+  NotifyItemListChanged();
   return true;
 }
 
 void DataObject::InternalAddFileItem(DataObjectItem* item) {
   ASSERT(item->Kind() == DataObjectItem::kFileKind);
   item_list_.push_back(item);
+  NotifyItemListChanged();
+}
+
+void DataObject::AddObserver(Observer* observer) {
+  DCHECK(!observers_.Contains(observer));
+  observers_.insert(observer);
+}
+
+void DataObject::NotifyItemListChanged() const {
+  for (const auto& observer : observers_)
+    observer->OnItemListChanged();
 }
 
 DEFINE_TRACE(DataObject) {
   visitor->Trace(item_list_);
+  visitor->Trace(observers_);
   Supplementable<DataObject>::Trace(visitor);
 }
 
 DataObject* DataObject::Create(WebDragData data) {
   DataObject* data_object = Create();
   bool has_file_system = false;
 
   WebVector<WebDragData::Item> items = data.Items();
   for (unsigned i = 0; i < items.size(); ++i) {
     WebDragData::Item item = items[i];
@@ skipping 90 matching lines @@
     } else {
       NOTREACHED();
     }
     item_list[i] = item;
   }
   data.SwapItems(item_list);
   return data;
 }
 
 }  // namespace blink