There are a lot of separate ipcv2 patches collected here in one file.

Some of them are Studio specific and can hopefully be removed.

In more detail: 

First part is for studio, we may be able to remove. 

Need to keep the if defined(OS_LINUX)... parts, should try to send upstream. 

Using evpoll/devpoll instead of epoll may be Studio specific. 

asm_volatile changes may also be studio specific. 

For Solaris, we have no proc/self/exe location so we get the name of the 

process some other way. Should be able to send this part upstream. 

Patch to use FTS (tool for traversing tool hierarchies). We have these

functions but they're not in libraries for C. This part is included in firefox

40. 

ENABLE_XSS_SUPPORT links XSS libraries; needs further investigation. 

In Solaris, the queue can be too long so we have it read 32 bits only (?) for

the wakeup_pip_read function. 

DCHECK(std::find...) may be because we couldn't compile it otherwise. Needs

namespace added. 

We can remove the part for wstring because it's for studio. 

Solaris specific change for adding definition of thr_self. 

Differing memory for munmap((caddr_t)... patch

We don't have timestruct defined in solaris (#ifndef SOLARIS...timstruct...)

event2/event-config.h: Adds a new file so that libevent will compile on Solaris.In the .mozconfig file, we are using system libevent, so this shouldn't be necessary.

IPC_RMID -- shared memory; on solaris, need to detach the shared memory first. So we move that segment of code up. If we detach the memory in Solaris, we cannot do a new attach.

Add flags for Studio compiler. (CXXFLAGS)

extern *C* int madvise(...) not defined , so we need to define it.

diff --git a/configure b/configure

--- a/configure

+++ b/configure

@@ -9647,7 +9647,7 @@

 EOF

        CFLAGS="$CFLAGS -xlibmieee -xstrconst -xbuiltin=%all -D__FUNCTION__=__func__"

-       CXXFLAGS="$CXXFLAGS -xlibmieee -xbuiltin=%all -features=tmplife,tmplrefstatic,extensions,no%except -norunpath -D__FUNCTION__=__func__ -template=no%extdef"

+       CXXFLAGS="$CXXFLAGS -xlibmieee -xbuiltin=%all -features=tmplife,tmplrefstatic,extensions,no%except -norunpath -D__FUNCTION__=__func__ -template=no%extdef -D_XOPEN_SOURCE=500 -D__EXTENSIONS__"

        LDFLAGS="-xildoff $LDFLAGS"

        MMX_FLAGS="-xarch=mmx -xO4"

        SSE_FLAGS="-xarch=sse -xO4"

diff --git a/dom/plugins/ipc/PluginMessageUtils.cpp b/dom/plugins/ipc/PluginMessageUtils.cpp

--- a/dom/plugins/ipc/PluginMessageUtils.cpp

+++ b/dom/plugins/ipc/PluginMessageUtils.cpp

@@ -85,7 +85,7 @@

   }

 }

-#if defined(OS_LINUX)

+#if defined(OS_LINUX) || defined(OS_SOLARIS)

 static string

 ReplaceAll(const string& haystack, const string& needle, const string& with)

 {

@@ -104,7 +104,7 @@

 string

 MungePluginDsoPath(const string& path)

 {

-#if defined(OS_LINUX)

+#if defined(OS_LINUX) || defined(OS_SOLARIS)

   // https://bugzilla.mozilla.org/show_bug.cgi?id=519601

   return ReplaceAll(path, "netscape", "netsc@pe");

 #else

@@ -115,7 +115,7 @@

 string

 UnmungePluginDsoPath(const string& munged)

 {

-#if defined(OS_LINUX)

+#if defined(OS_LINUX) || defined(OS_SOLARIS)

   return ReplaceAll(munged, "netsc@pe", "netscape");

 #else

   return munged;

diff --git a/dom/plugins/ipc/PluginModuleChild.cpp b/dom/plugins/ipc/PluginModuleChild.cpp

--- a/dom/plugins/ipc/PluginModuleChild.cpp

+++ b/dom/plugins/ipc/PluginModuleChild.cpp

@@ -320,7 +320,7 @@

     // TODO: use PluginPRLibrary here

-#if defined(OS_LINUX) || defined(OS_BSD)

+#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)

     mShutdownFunc =

         (NP_PLUGINSHUTDOWN) PR_FindFunctionSymbol(mLibrary, "NP_Shutdown");

@@ -351,9 +351,11 @@

 }

 #if defined(MOZ_WIDGET_GTK)

+extern "C" {

 typedef void (*GObjectDisposeFn)(GObject*);

 typedef gboolean (*GtkWidgetScrollEventFn)(GtkWidget*, GdkEventScroll*);

 typedef void (*GtkPlugEmbeddedFn)(GtkPlug*);

+}

 static GObjectDisposeFn real_gtk_plug_dispose;

 static GtkPlugEmbeddedFn real_gtk_plug_embedded;

@@ -1882,7 +1884,7 @@

     AssertPluginThread();

     MOZ_ASSERT(mIsChrome);

-#if defined(OS_LINUX) || defined(OS_BSD)

+#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)

     return true;

 #elif defined(OS_WIN) || defined(OS_MACOSX)

     *_retval = mGetEntryPointsFunc(&mFunctions);

@@ -1927,7 +1929,7 @@

 #endif

     NPError result;

-#if defined(OS_LINUX) || defined(OS_BSD)

+#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)

     result = mInitializeFunc(&sBrowserFuncs, &mFunctions);

 #elif defined(OS_WIN) || defined(OS_MACOSX)

     result = mInitializeFunc(&sBrowserFuncs);

diff --git a/dom/plugins/ipc/PluginModuleChild.h b/dom/plugins/ipc/PluginModuleChild.h

--- a/dom/plugins/ipc/PluginModuleChild.h

+++ b/dom/plugins/ipc/PluginModuleChild.h

@@ -328,7 +328,7 @@

     // we get this from the plugin

     NP_PLUGINSHUTDOWN mShutdownFunc;

-#if defined(OS_LINUX) || defined(OS_BSD)

+#if defined(OS_LINUX) || defined(OS_BSD) || defined(OS_SOLARIS)

     NP_PLUGINUNIXINIT mInitializeFunc;

 #elif defined(OS_WIN) || defined(OS_MACOSX)

     NP_PLUGININIT mInitializeFunc;

diff --git a/ipc/chromium/chromium-config.mozbuild b/ipc/chromium/chromium-config.mozbuild

--- a/ipc/chromium/chromium-config.mozbuild

+++ b/ipc/chromium/chromium-config.mozbuild

@@ -45,6 +45,9 @@

     if CONFIG['OS_ARCH'] == 'Darwin':

         DEFINES['OS_MACOSX'] = 1

+    elif CONFIG['OS_ARCH'] == 'SunOS':

+        DEFINES['OS_SOLARIS'] = 1

+

     elif CONFIG['OS_ARCH'] == 'DragonFly':

         DEFINES.update({

             'OS_DRAGONFLY': 1,

diff --git a/ipc/chromium/src/base/atomicops_internals_x86_gcc.cc b/ipc/chromium/src/base/atomicops_internals_x86_gcc.cc

--- a/ipc/chromium/src/base/atomicops_internals_x86_gcc.cc

+++ b/ipc/chromium/src/base/atomicops_internals_x86_gcc.cc

@@ -19,13 +19,13 @@

 // Inline cpuid instruction.  In PIC compilations, %ebx contains the address

 // of the global offset table.  To avoid breaking such executables, this code

 // must preserve that register's value across cpuid instructions.

-#if defined(__i386__)

+#if defined(__i386__) || defined (__i386)

 #define cpuid(a, b, c, d, inp) \

   asm ("mov %%ebx, %%edi\n"    \

        "cpuid\n"               \

        "xchg %%edi, %%ebx\n"   \

        : "=a" (a), "=D" (b), "=c" (c), "=d" (d) : "a" (inp))

-#elif defined (__x86_64__)

+#elif defined (__x86_64__) || defined(__x86_64)

 #define cpuid(a, b, c, d, inp) \

   asm ("mov %%rbx, %%rdi\n"    \

        "cpuid\n"               \

diff --git a/ipc/chromium/src/base/atomicops_internals_x86_gcc.h b/ipc/chromium/src/base/atomicops_internals_x86_gcc.h

--- a/ipc/chromium/src/base/atomicops_internals_x86_gcc.h

+++ b/ipc/chromium/src/base/atomicops_internals_x86_gcc.h

@@ -29,18 +29,18 @@

                                          Atomic32 old_value,

                                          Atomic32 new_value) {

   Atomic32 prev;

-  __asm__ __volatile__("lock; cmpxchgl %1,%2"

+  __asm__ __volatile__("lock; cmpxchgl %1,(%2)"

                        : "=a" (prev)

-                       : "q" (new_value), "m" (*ptr), "0" (old_value)

+                       : "q" (new_value), "r" (ptr), "0" (old_value)

                        : "memory");

   return prev;

 }

 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,

                                          Atomic32 new_value) {

-  __asm__ __volatile__("xchgl %1,%0"  // The lock prefix is implicit for xchg.

+  __asm__ __volatile__("xchgl (%1),%0"  // The lock prefix is implicit for xchg.

                        : "=r" (new_value)

-                       : "m" (*ptr), "0" (new_value)

+                       : "r" (ptr), "0" (new_value)

                        : "memory");

   return new_value;  // Now it's the previous value.

 }

@@ -48,8 +48,8 @@

 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,

                                           Atomic32 increment) {

   Atomic32 temp = increment;

-  __asm__ __volatile__("lock; xaddl %0,%1"

-                       : "+r" (temp), "+m" (*ptr)

+  __asm__ __volatile__("lock; xaddl %0,(%1)"

+                       : "+r" (temp), "+r" (ptr)

                        : : "memory");

   // temp now holds the old value of *ptr

   return temp + increment;

@@ -58,8 +58,8 @@

 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,

                                         Atomic32 increment) {

   Atomic32 temp = increment;

-  __asm__ __volatile__("lock; xaddl %0,%1"

-                       : "+r" (temp), "+m" (*ptr)

+  __asm__ __volatile__("lock; xaddl %0,(%1)"

+                       : "+r" (temp), "+r" (ptr)

                        : : "memory");

   // temp now holds the old value of *ptr

   if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {

@@ -153,18 +153,18 @@

                                          Atomic64 old_value,

                                          Atomic64 new_value) {

   Atomic64 prev;

-  __asm__ __volatile__("lock; cmpxchgq %1,%2"

+  __asm__ __volatile__("lock; cmpxchgq %1,(%2)"

                        : "=a" (prev)

-                       : "q" (new_value), "m" (*ptr), "0" (old_value)

+                       : "q" (new_value), "r" (ptr), "0" (old_value)

                        : "memory");

   return prev;

 }

 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,

                                          Atomic64 new_value) {

-  __asm__ __volatile__("xchgq %1,%0"  // The lock prefix is implicit for xchg.

+  __asm__ __volatile__("xchgq (%1),%0"  // The lock prefix is implicit for xchg.

                        : "=r" (new_value)

-                       : "m" (*ptr), "0" (new_value)

+                       : "r" (ptr), "0" (new_value)

                        : "memory");

   return new_value;  // Now it's the previous value.

 }

@@ -172,8 +172,8 @@

 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,

                                           Atomic64 increment) {

   Atomic64 temp = increment;

-  __asm__ __volatile__("lock; xaddq %0,%1"

-                       : "+r" (temp), "+m" (*ptr)

+  __asm__ __volatile__("lock; xaddq %0,(%1)"

+                       : "+r" (temp), "+r" (ptr)

                        : : "memory");

   // temp now contains the previous value of *ptr

   return temp + increment;

@@ -182,8 +182,8 @@

 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,

                                         Atomic64 increment) {

   Atomic64 temp = increment;

-  __asm__ __volatile__("lock; xaddq %0,%1"

-                       : "+r" (temp), "+m" (*ptr)

+  __asm__ __volatile__("lock; xaddq %0,(%1)"

+                       : "+r" (temp), "+r" (ptr)

                        : : "memory");

   // temp now contains the previous value of *ptr

   if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {

diff --git a/ipc/chromium/src/base/file_util.cc b/ipc/chromium/src/base/file_util.cc

--- a/ipc/chromium/src/base/file_util.cc

+++ b/ipc/chromium/src/base/file_util.cc

@@ -245,4 +245,25 @@

 int WriteFile(const std::wstring& filename, const char* data, int size) {

   return WriteFile(FilePath::FromWStringHack(filename), data, size);

 }

+

+#ifdef OS_SOLARIS

+

+bool IsDot(const FilePath& path) {

+  return FILE_PATH_LITERAL(".") == path.BaseName().value();

+}

+

+bool IsDotDot(const FilePath& path) {

+  return FILE_PATH_LITERAL("..") == path.BaseName().value();

+}

+

+///////////////////////////////////////////////

+// FileEnumerator

+//

+// Note: the main logic is in file_util_<platform>.cc

+

+bool FileEnumerator::ShouldSkip(const FilePath& path) {

+  FilePath::StringType basename = path.BaseName().value();

+  return IsDot(path) || (IsDotDot(path) && !(INCLUDE_DOT_DOT & file_type_));

+}

+#endif

 }  // namespace

diff --git a/ipc/chromium/src/base/file_util.h b/ipc/chromium/src/base/file_util.h

--- a/ipc/chromium/src/base/file_util.h

+++ b/ipc/chromium/src/base/file_util.h

@@ -12,7 +12,7 @@

 #if defined(OS_WIN)

 #include <windows.h>

-#elif defined(ANDROID)

+#elif defined(ANDROID) || defined(OS_SOLARIS)

 #include <sys/stat.h>

 #elif defined(OS_POSIX) 

 #include <sys/types.h>

@@ -240,6 +240,103 @@

 // Deprecated temporary compatibility function.

 bool SetCurrentDirectory(const std::wstring& current_directory);

+#ifdef OS_SOLARIS

+// A class for enumerating the files in a provided path. The order of the

+// results is not guaranteed.

+//

+// DO NOT USE FROM THE MAIN THREAD of your application unless it is a test

+// program where latency does not matter. This class is blocking.

+class FileEnumerator {

+ public:

+  typedef struct {

+    struct stat stat;

+    std::string filename;

+  } FindInfo;

+

+  enum FILE_TYPE {

+    FILES                 = 1 << 0,

+    DIRECTORIES           = 1 << 1,

+    INCLUDE_DOT_DOT       = 1 << 2,

+    SHOW_SYM_LINKS        = 1 << 4,

+  };

+

+  // |root_path| is the starting directory to search for. It may or may not end

+  // in a slash.

+  //  

+  // If |recursive| is true, this will enumerate all matches in any

+  // subdirectories matched as well. It does a breadth-first search, so all

+  // files in one directory will be returned before any files in a

+  // subdirectory.

+  //

+  // |file_type| specifies whether the enumerator should match files,

+  // directories, or both.

+  //

+  // |pattern| is an optional pattern for which files to match. This

+  // works like shell globbing. For example, "*.txt" or "Foo???.doc".

+  // However, be careful in specifying patterns that aren't cross platform

+  // since the underlying code uses OS-specific matching routines.  In general,

+  // Windows matching is less featureful than others, so test there first.

+  // If unspecified, this will match all files.

+  // NOTE: the pattern only matches the contents of root_path, not files in

+  // recursive subdirectories.

+  // TODO(erikkay): Fix the pattern matching to work at all levels.

+  FileEnumerator(const FilePath& root_path,

+                 bool recursive,

+                 FileEnumerator::FILE_TYPE file_type);

+  FileEnumerator(const FilePath& root_path,

+                 bool recursive,

+                 FileEnumerator::FILE_TYPE file_type,

+                 const FilePath::StringType& pattern);

+  ~FileEnumerator();

+

+  // Returns an empty string if there are no more results.

+  FilePath Next();

+

+  // Write the file info into |info|.

+  void GetFindInfo(FindInfo* info);

+

+  // Looks inside a FindInfo and determines if it's a directory.

+  static bool IsDirectory(const FindInfo& info);

+

+  static FilePath GetFilename(const FindInfo& find_info);

+

+ private:

+  // Returns true if the given path should be skipped in enumeration.

+  bool ShouldSkip(const FilePath& path);

+

+

+  typedef struct {

+    FilePath filename;

+    struct stat stat;

+  } DirectoryEntryInfo;

+

+  // Read the filenames in source into the vector of DirectoryEntryInfo's

+  static bool ReadDirectory(std::vector<DirectoryEntryInfo>* entries,

+                            const FilePath& source, bool show_links);

+

+  // The files in the current directory

+  std::vector<DirectoryEntryInfo> directory_entries_;

+

+  // The next entry to use from the directory_entries_ vector

+  size_t current_directory_entry_;

+

+  FilePath root_path_;

+  bool recursive_;

+  FILE_TYPE file_type_;

+  FilePath::StringType pattern_;  // Empty when we want to find everything.

+

+  // Set to true when there is a find operation open. This way, we can lazily

+  // start the operations when the caller calls Next().

+  bool is_in_find_op_;

+

+  // A stack that keeps track of which subdirectories we still need to

+  // enumerate in the breadth-first search.

+  std::stack<FilePath> pending_paths_;

+

+  DISALLOW_COPY_AND_ASSIGN(FileEnumerator);

+};

+#endif

+

 }  // namespace file_util

 #endif  // BASE_FILE_UTIL_H_

diff --git a/ipc/chromium/src/base/file_util_posix.cc b/ipc/chromium/src/base/file_util_posix.cc

--- a/ipc/chromium/src/base/file_util_posix.cc

+++ b/ipc/chromium/src/base/file_util_posix.cc

@@ -446,7 +555,7 @@

 }

 bool GetShmemTempDir(FilePath* path) {

-#if defined(OS_LINUX) && !defined(ANDROID)

+#if defined(OS_LINUX) && !defined(ANDROID) && !defined(OS_SOLARIS)

   *path = FilePath("/dev/shm");

   return true;

 #else

@@ -501,4 +610,144 @@

 }

 #endif // !defined(OS_MACOSX)

+#ifdef OS_SOLARIS

+///////////////////////////////////////////////

+// FileEnumerator

+

+FileEnumerator::FileEnumerator(const FilePath& root_path,

+                               bool recursive,

+                               FileEnumerator::FILE_TYPE file_type)

+    : current_directory_entry_(0),

+      root_path_(root_path),

+      recursive_(recursive),

+      file_type_(file_type),

+      is_in_find_op_(false) {

+  // INCLUDE_DOT_DOT must not be specified if recursive.

+  DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_)));

+  pending_paths_.push(root_path);

+}

+

+FileEnumerator::FileEnumerator(const FilePath& root_path,

+                               bool recursive,

+                               FileEnumerator::FILE_TYPE file_type,

+                               const FilePath::StringType& pattern)

+    : current_directory_entry_(0),

+      root_path_(root_path),

+      recursive_(recursive),

+      file_type_(file_type),

+      pattern_(root_path.Append(pattern).value()),

+      is_in_find_op_(false) {

+  // INCLUDE_DOT_DOT must not be specified if recursive.

+  DCHECK(!(recursive && (INCLUDE_DOT_DOT & file_type_)));

+  // The Windows version of this code appends the pattern to the root_path,

+  // potentially only matching against items in the top-most directory.

+  // Do the same here.

+  if (pattern.size() == 0)

+    pattern_ = FilePath::StringType();

+  pending_paths_.push(root_path);

+}

+

+FileEnumerator::~FileEnumerator() {

+}

+

+void FileEnumerator::GetFindInfo(FindInfo* info) {

+  DCHECK(info);

+

+  if (current_directory_entry_ >= directory_entries_.size())

+    return;

+

+  DirectoryEntryInfo* cur_entry = &directory_entries_[current_directory_entry_];

+  memcpy(&(info->stat), &(cur_entry->stat), sizeof(info->stat));

+  info->filename.assign(cur_entry->filename.value());

+}

+

+bool FileEnumerator::IsDirectory(const FindInfo& info) {

+  return S_ISDIR(info.stat.st_mode);

+}

+

+// static

+FilePath FileEnumerator::GetFilename(const FindInfo& find_info) {

+  return FilePath(find_info.filename);

+}

+

+FilePath FileEnumerator::Next() {

+  ++current_directory_entry_;

+

+  // While we've exhausted the entries in the current directory, do the next

+  while (current_directory_entry_ >= directory_entries_.size()) {

+    if (pending_paths_.empty())

+      return FilePath();

+

+    root_path_ = pending_paths_.top();

+    root_path_ = root_path_.StripTrailingSeparators();

+    pending_paths_.pop();

+

+    std::vector<DirectoryEntryInfo> entries;

+    if (!ReadDirectory(&entries, root_path_, file_type_ & SHOW_SYM_LINKS))

+      continue;

+

+    directory_entries_.clear();

+    current_directory_entry_ = 0;

+    for (std::vector<DirectoryEntryInfo>::const_iterator

+        i = entries.begin(); i != entries.end(); ++i) {

+      FilePath full_path = root_path_.Append(i->filename);

+      if (ShouldSkip(full_path))

+        continue;

+

+      if (pattern_.size() &&

+          fnmatch(pattern_.c_str(), full_path.value().c_str(), FNM_NOESCAPE))

+        continue;

+

+      if (recursive_ && S_ISDIR(i->stat.st_mode))

+        pending_paths_.push(full_path);

+

+      if ((S_ISDIR(i->stat.st_mode) && (file_type_ & DIRECTORIES)) ||

+          (!S_ISDIR(i->stat.st_mode) && (file_type_ & FILES)))

+        directory_entries_.push_back(*i);

+    }

+  }

+

+  return root_path_.Append(directory_entries_[current_directory_entry_

+      ].filename);

+}

+

+bool FileEnumerator::ReadDirectory(std::vector<DirectoryEntryInfo>* entries,

+                                   const FilePath& source, bool show_links) {

+

+  DIR* dir = opendir(source.value().c_str());